/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to breezy/branch.py

Support user.signingkey configuration variable in .git/config.

Merged from https://code.launchpad.net/~jelmer/brz/local-git-key/+merge/381000

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/branch.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2012 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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
 
18
 
from cStringIO import StringIO
19
 
import sys
20
 
 
21
 
from bzrlib.lazy_import import lazy_import
 
17
from __future__ import absolute_import
 
18
 
 
19
from .lazy_import import lazy_import
22
20
lazy_import(globals(), """
23
 
from itertools import chain
24
 
from bzrlib import (
25
 
        bzrdir,
26
 
        cache_utf8,
27
 
        config as _mod_config,
28
 
        debug,
29
 
        errors,
30
 
        lockdir,
31
 
        lockable_files,
32
 
        repository,
33
 
        revision as _mod_revision,
34
 
        rio,
35
 
        symbol_versioning,
36
 
        transport,
37
 
        tsort,
38
 
        ui,
39
 
        urlutils,
40
 
        )
41
 
from bzrlib.config import BranchConfig, TransportConfig
42
 
from bzrlib.repofmt.pack_repo import RepositoryFormatKnitPack5RichRoot
43
 
from bzrlib.tag import (
44
 
    BasicTags,
45
 
    DisabledTags,
46
 
    )
 
21
import itertools
 
22
from breezy import (
 
23
    cleanup,
 
24
    config as _mod_config,
 
25
    debug,
 
26
    memorytree,
 
27
    repository,
 
28
    revision as _mod_revision,
 
29
    tag as _mod_tag,
 
30
    transport,
 
31
    ui,
 
32
    urlutils,
 
33
    )
 
34
from breezy.bzr import (
 
35
    fetch,
 
36
    remote,
 
37
    vf_search,
 
38
    )
 
39
from breezy.i18n import gettext, ngettext
47
40
""")
48
41
 
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
54
 
from bzrlib.symbol_versioning import (
55
 
    deprecated_in,
56
 
    deprecated_method,
57
 
    )
58
 
from bzrlib.trace import mutter, mutter_callsite, note, is_quiet
59
 
 
60
 
 
61
 
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
62
 
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
63
 
BZR_BRANCH_FORMAT_6 = "Bazaar Branch Format 6 (bzr 0.15)\n"
64
 
 
65
 
 
66
 
class Branch(bzrdir.ControlComponent):
 
42
from . import (
 
43
    controldir,
 
44
    errors,
 
45
    registry,
 
46
    )
 
47
from .hooks import Hooks
 
48
from .inter import InterObject
 
49
from .lock import LogicalLockResult
 
50
from .sixish import (
 
51
    text_type,
 
52
    viewitems,
 
53
    )
 
54
from .trace import mutter, mutter_callsite, note, is_quiet, warning
 
55
 
 
56
 
 
57
class UnstackableBranchFormat(errors.BzrError):
 
58
 
 
59
    _fmt = ("The branch '%(url)s'(%(format)s) is not a stackable format. "
 
60
            "You will need to upgrade the branch to permit branch stacking.")
 
61
 
 
62
    def __init__(self, format, url):
 
63
        errors.BzrError.__init__(self)
 
64
        self.format = format
 
65
        self.url = url
 
66
 
 
67
 
 
68
class Branch(controldir.ControlComponent):
67
69
    """Branch holding a history of revisions.
68
70
 
69
71
    :ivar base:
70
72
        Base directory/url of the branch; using control_url and
71
73
        control_transport is more standardized.
72
 
 
73
 
    hooks: An instance of BranchHooks.
 
74
    :ivar hooks: An instance of BranchHooks.
 
75
    :ivar _master_branch_cache: cached result of get_master_branch, see
 
76
        _clear_cached_state.
74
77
    """
75
78
    # this is really an instance variable - FIXME move it there
76
79
    # - RBC 20060112
82
85
 
83
86
    @property
84
87
    def user_transport(self):
85
 
        return self.bzrdir.user_transport
 
88
        return self.controldir.user_transport
86
89
 
87
 
    def __init__(self, *ignored, **ignored_too):
 
90
    def __init__(self, possible_transports=None):
88
91
        self.tags = self._format.make_tags(self)
89
92
        self._revision_history_cache = None
90
93
        self._revision_id_to_revno_cache = None
91
94
        self._partial_revision_id_to_revno_cache = {}
92
95
        self._partial_revision_history_cache = []
93
96
        self._last_revision_info_cache = None
 
97
        self._master_branch_cache = None
94
98
        self._merge_sorted_revisions_cache = None
95
 
        self._open_hook()
 
99
        self._open_hook(possible_transports)
96
100
        hooks = Branch.hooks['open']
97
101
        for hook in hooks:
98
102
            hook(self)
99
103
 
100
 
    def _open_hook(self):
 
104
    def _open_hook(self, possible_transports):
101
105
        """Called by init to allow simpler extension of the base class."""
102
106
 
103
 
    def _activate_fallback_location(self, url):
 
107
    def _activate_fallback_location(self, url, possible_transports):
104
108
        """Activate the branch/repository from url as a fallback repository."""
105
 
        repo = self._get_fallback_repository(url)
 
109
        for existing_fallback_repo in self.repository._fallback_repositories:
 
110
            if existing_fallback_repo.user_url == url:
 
111
                # This fallback is already configured.  This probably only
 
112
                # happens because ControlDir.sprout is a horrible mess.  To
 
113
                # avoid confusing _unstack we don't add this a second time.
 
114
                mutter('duplicate activation of fallback %r on %r', url, self)
 
115
                return
 
116
        repo = self._get_fallback_repository(url, possible_transports)
106
117
        if repo.has_same_location(self.repository):
107
118
            raise errors.UnstackableLocationError(self.user_url, url)
108
119
        self.repository.add_fallback_repository(repo)
123
134
 
124
135
    def _check_stackable_repo(self):
125
136
        if not self.repository._format.supports_external_lookups:
126
 
            raise errors.UnstackableRepositoryFormat(self.repository._format,
127
 
                self.repository.base)
 
137
            raise errors.UnstackableRepositoryFormat(
 
138
                self.repository._format, self.repository.base)
128
139
 
129
140
    def _extend_partial_history(self, stop_index=None, stop_revision=None):
130
141
        """Extend the partial history to include a given index
144
155
        repository._iter_for_revno(
145
156
            self.repository, self._partial_revision_history_cache,
146
157
            stop_index=stop_index, stop_revision=stop_revision)
147
 
        if self._partial_revision_history_cache[-1] == _mod_revision.NULL_REVISION:
 
158
        if self._partial_revision_history_cache[-1] == \
 
159
                _mod_revision.NULL_REVISION:
148
160
            self._partial_revision_history_cache.pop()
149
161
 
150
162
    def _get_check_refs(self):
151
163
        """Get the references needed for check().
152
164
 
153
 
        See bzrlib.check.
 
165
        See breezy.check.
154
166
        """
155
167
        revid = self.last_revision()
156
168
        return [('revision-existence', revid), ('lefthand-distance', revid)]
162
174
        For instance, if the branch is at URL/.bzr/branch,
163
175
        Branch.open(URL) -> a Branch instance.
164
176
        """
165
 
        control = bzrdir.BzrDir.open(base, _unsupported,
166
 
                                     possible_transports=possible_transports)
167
 
        return control.open_branch(unsupported=_unsupported)
 
177
        control = controldir.ControlDir.open(
 
178
            base, possible_transports=possible_transports,
 
179
            _unsupported=_unsupported)
 
180
        return control.open_branch(
 
181
            unsupported=_unsupported,
 
182
            possible_transports=possible_transports)
168
183
 
169
184
    @staticmethod
170
 
    def open_from_transport(transport, name=None, _unsupported=False):
 
185
    def open_from_transport(transport, name=None, _unsupported=False,
 
186
                            possible_transports=None):
171
187
        """Open the branch rooted at transport"""
172
 
        control = bzrdir.BzrDir.open_from_transport(transport, _unsupported)
173
 
        return control.open_branch(name=name, unsupported=_unsupported)
 
188
        control = controldir.ControlDir.open_from_transport(
 
189
            transport, _unsupported)
 
190
        return control.open_branch(
 
191
            name=name, unsupported=_unsupported,
 
192
            possible_transports=possible_transports)
174
193
 
175
194
    @staticmethod
176
195
    def open_containing(url, possible_transports=None):
180
199
 
181
200
        Basically we keep looking up until we find the control directory or
182
201
        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
184
 
        format, UnknownFormatError or UnsupportedFormatError are raised.
185
 
        If there is one, it is returned, along with the unused portion of url.
 
202
        If there is one and it is either an unrecognised format or an
 
203
        unsupported format, UnknownFormatError or UnsupportedFormatError are
 
204
        raised.  If there is one, it is returned, along with the unused portion
 
205
        of url.
186
206
        """
187
 
        control, relpath = bzrdir.BzrDir.open_containing(url,
188
 
                                                         possible_transports)
189
 
        return control.open_branch(), relpath
 
207
        control, relpath = controldir.ControlDir.open_containing(
 
208
            url, possible_transports)
 
209
        branch = control.open_branch(possible_transports=possible_transports)
 
210
        return (branch, relpath)
190
211
 
191
212
    def _push_should_merge_tags(self):
192
213
        """Should _basic_push merge this branch's tags into the target?
197
218
        return self.supports_tags() and self.tags.get_tag_dict()
198
219
 
199
220
    def get_config(self):
200
 
        return BranchConfig(self)
201
 
 
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):
 
221
        """Get a breezy.config.BranchConfig for this Branch.
 
222
 
 
223
        This can then be used to get and set configuration options for the
 
224
        branch.
 
225
 
 
226
        :return: A breezy.config.BranchConfig.
 
227
        """
 
228
        return _mod_config.BranchConfig(self)
 
229
 
 
230
    def get_config_stack(self):
 
231
        """Get a breezy.config.BranchStack for this Branch.
 
232
 
 
233
        This can then be used to get and set configuration options for the
 
234
        branch.
 
235
 
 
236
        :return: A breezy.config.BranchStack.
 
237
        """
 
238
        return _mod_config.BranchStack(self)
 
239
 
 
240
    def store_uncommitted(self, creator):
 
241
        """Store uncommitted changes from a ShelfCreator.
 
242
 
 
243
        :param creator: The ShelfCreator containing uncommitted changes, or
 
244
            None to delete any stored changes.
 
245
        :raises: ChangesAlreadyStored if the branch already has changes.
 
246
        """
 
247
        raise NotImplementedError(self.store_uncommitted)
 
248
 
 
249
    def get_unshelver(self, tree):
 
250
        """Return a shelf.Unshelver for this branch and tree.
 
251
 
 
252
        :param tree: The tree to use to construct the Unshelver.
 
253
        :return: an Unshelver or None if no changes are stored.
 
254
        """
 
255
        raise NotImplementedError(self.get_unshelver)
 
256
 
 
257
    def _get_fallback_repository(self, url, possible_transports):
215
258
        """Get the repository we fallback to at url."""
216
259
        url = urlutils.join(self.base, url)
217
 
        a_branch = Branch.open(url,
218
 
            possible_transports=[self.bzrdir.root_transport])
 
260
        a_branch = Branch.open(url, possible_transports=possible_transports)
219
261
        return a_branch.repository
220
262
 
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
263
    def _get_nick(self, local=False, possible_transports=None):
236
264
        config = self.get_config()
237
265
        # explicit overrides master, but don't look for master if local is True
238
266
        if not local and not config.has_explicit_nickname():
239
267
            try:
240
268
                master = self.get_master_branch(possible_transports)
 
269
                if master and self.user_url == master.user_url:
 
270
                    raise errors.RecursiveBind(self.user_url)
241
271
                if master is not None:
242
272
                    # return the master branch value
243
273
                    return master.nick
244
 
            except errors.BzrError, e:
 
274
            except errors.RecursiveBind as e:
 
275
                raise e
 
276
            except errors.BzrError as e:
245
277
                # Silently fall back to local implicit nick if the master is
246
278
                # unavailable
247
279
                mutter("Could not connect to bound branch, "
248
 
                    "falling back to local nick.\n " + str(e))
 
280
                       "falling back to local nick.\n " + str(e))
249
281
        return config.get_nickname()
250
282
 
251
283
    def _set_nick(self, nick):
274
306
        new_history = []
275
307
        check_not_reserved_id = _mod_revision.check_not_reserved_id
276
308
        # 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):
 
309
        while (current_rev_id in parents_map
 
310
               and len(parents_map[current_rev_id]) > 0):
279
311
            check_not_reserved_id(current_rev_id)
280
312
            new_history.append(current_rev_id)
281
313
            current_rev_id = parents_map[current_rev_id][0]
283
315
        new_history.reverse()
284
316
        return new_history
285
317
 
286
 
    def lock_write(self):
 
318
    def lock_write(self, token=None):
 
319
        """Lock the branch for write operations.
 
320
 
 
321
        :param token: A token to permit reacquiring a previously held and
 
322
            preserved lock.
 
323
        :return: A BranchWriteLockResult.
 
324
        """
287
325
        raise NotImplementedError(self.lock_write)
288
326
 
289
327
    def lock_read(self):
 
328
        """Lock the branch for read operations.
 
329
 
 
330
        :return: A breezy.lock.LogicalLockResult.
 
331
        """
290
332
        raise NotImplementedError(self.lock_read)
291
333
 
292
334
    def unlock(self):
299
341
    def get_physical_lock_status(self):
300
342
        raise NotImplementedError(self.get_physical_lock_status)
301
343
 
302
 
    @needs_read_lock
303
344
    def dotted_revno_to_revision_id(self, revno, _cache_reverse=False):
304
345
        """Return the revision_id for a dotted revno.
305
346
 
311
352
        :return: the revision_id
312
353
        :raises errors.NoSuchRevision: if the revno doesn't exist
313
354
        """
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
 
355
        with self.lock_read():
 
356
            rev_id = self._do_dotted_revno_to_revision_id(revno)
 
357
            if _cache_reverse:
 
358
                self._partial_revision_id_to_revno_cache[rev_id] = revno
 
359
            return rev_id
318
360
 
319
361
    def _do_dotted_revno_to_revision_id(self, revno):
320
362
        """Worker function for dotted_revno_to_revision_id.
323
365
        provide a more efficient implementation.
324
366
        """
325
367
        if len(revno) == 1:
326
 
            return self.get_rev_id(revno[0])
 
368
            try:
 
369
                return self.get_rev_id(revno[0])
 
370
            except errors.RevisionNotPresent as e:
 
371
                raise errors.GhostRevisionsHaveNoRevno(revno[0], e.revision_id)
327
372
        revision_id_to_revno = self.get_revision_id_to_revno_map()
328
373
        revision_ids = [revision_id for revision_id, this_revno
329
 
                        in revision_id_to_revno.iteritems()
 
374
                        in viewitems(revision_id_to_revno)
330
375
                        if revno == this_revno]
331
376
        if len(revision_ids) == 1:
332
377
            return revision_ids[0]
334
379
            revno_str = '.'.join(map(str, revno))
335
380
            raise errors.NoSuchRevision(self, revno_str)
336
381
 
337
 
    @needs_read_lock
338
382
    def revision_id_to_dotted_revno(self, revision_id):
339
383
        """Given a revision id, return its dotted revno.
340
384
 
341
385
        :return: a tuple like (1,) or (400,1,3).
342
386
        """
343
 
        return self._do_revision_id_to_dotted_revno(revision_id)
 
387
        with self.lock_read():
 
388
            return self._do_revision_id_to_dotted_revno(revision_id)
344
389
 
345
390
    def _do_revision_id_to_dotted_revno(self, revision_id):
346
391
        """Worker function for revision_id_to_revno."""
363
408
                raise errors.NoSuchRevision(self, revision_id)
364
409
        return result
365
410
 
366
 
    @needs_read_lock
367
411
    def get_revision_id_to_revno_map(self):
368
412
        """Return the revision_id => dotted revno map.
369
413
 
372
416
        :return: A dictionary mapping revision_id => dotted revno.
373
417
            This dictionary should not be modified by the caller.
374
418
        """
375
 
        if self._revision_id_to_revno_cache is not None:
376
 
            mapping = self._revision_id_to_revno_cache
377
 
        else:
378
 
            mapping = self._gen_revno_map()
379
 
            self._cache_revision_id_to_revno(mapping)
380
 
        # TODO: jam 20070417 Since this is being cached, should we be returning
381
 
        #       a copy?
382
 
        # I would rather not, and instead just declare that users should not
383
 
        # modify the return value.
384
 
        return mapping
 
419
        if 'evil' in debug.debug_flags:
 
420
            mutter_callsite(
 
421
                3, "get_revision_id_to_revno_map scales with ancestry.")
 
422
        with self.lock_read():
 
423
            if self._revision_id_to_revno_cache is not None:
 
424
                mapping = self._revision_id_to_revno_cache
 
425
            else:
 
426
                mapping = self._gen_revno_map()
 
427
                self._cache_revision_id_to_revno(mapping)
 
428
            # TODO: jam 20070417 Since this is being cached, should we be
 
429
            # returning a copy?
 
430
            # I would rather not, and instead just declare that users should
 
431
            # not modify the return value.
 
432
            return mapping
385
433
 
386
434
    def _gen_revno_map(self):
387
435
        """Create a new mapping from revision ids to dotted revnos.
393
441
 
394
442
        :return: A dictionary mapping revision_id => dotted revno.
395
443
        """
396
 
        revision_id_to_revno = dict((rev_id, revno)
397
 
            for rev_id, depth, revno, end_of_merge
398
 
             in self.iter_merge_sorted_revisions())
 
444
        revision_id_to_revno = {
 
445
            rev_id: revno for rev_id, depth, revno, end_of_merge
 
446
            in self.iter_merge_sorted_revisions()}
399
447
        return revision_id_to_revno
400
448
 
401
 
    @needs_read_lock
402
449
    def iter_merge_sorted_revisions(self, start_revision_id=None,
403
 
            stop_revision_id=None, stop_rule='exclude', direction='reverse'):
 
450
                                    stop_revision_id=None,
 
451
                                    stop_rule='exclude', direction='reverse'):
404
452
        """Walk the revisions for a branch in merge sorted order.
405
453
 
406
454
        Merge sorted order is the output from a merge-aware,
413
461
            after. If None, the rest of history is included.
414
462
        :param stop_rule: if stop_revision_id is not None, the precise rule
415
463
            to use for termination:
 
464
 
416
465
            * 'exclude' - leave the stop revision out of the result (default)
417
466
            * 'include' - the stop revision is the last item in the result
418
467
            * 'with-merges' - include the stop revision and all of its
419
468
              merged revisions in the result
420
 
            * 'with-merges-without-common-ancestry' - filter out revisions 
 
469
            * 'with-merges-without-common-ancestry' - filter out revisions
421
470
              that are in both ancestries
422
471
        :param direction: either 'reverse' or 'forward':
 
472
 
423
473
            * reverse means return the start_revision_id first, i.e.
424
474
              start at the most recent revision and go backwards in history
425
475
            * forward returns tuples in the opposite order to reverse.
441
491
            * end_of_merge: When True the next node (earlier in history) is
442
492
              part of a different merge.
443
493
        """
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)
 
494
        with self.lock_read():
 
495
            # Note: depth and revno values are in the context of the branch so
 
496
            # we need the full graph to get stable numbers, regardless of the
 
497
            # start_revision_id.
 
498
            if self._merge_sorted_revisions_cache is None:
 
499
                last_revision = self.last_revision()
 
500
                known_graph = self.repository.get_known_graph_ancestry(
 
501
                    [last_revision])
 
502
                self._merge_sorted_revisions_cache = known_graph.merge_sort(
 
503
                    last_revision)
 
504
            filtered = self._filter_merge_sorted_revisions(
 
505
                self._merge_sorted_revisions_cache, start_revision_id,
 
506
                stop_revision_id, stop_rule)
 
507
            # Make sure we don't return revisions that are not part of the
 
508
            # start_revision_id ancestry.
 
509
            filtered = self._filter_start_non_ancestors(filtered)
 
510
            if direction == 'reverse':
 
511
                return filtered
 
512
            if direction == 'forward':
 
513
                return reversed(list(filtered))
 
514
            else:
 
515
                raise ValueError('invalid direction %r' % direction)
465
516
 
466
517
    def _filter_merge_sorted_revisions(self, merge_sorted_revisions,
467
 
        start_revision_id, stop_revision_id, stop_rule):
 
518
                                       start_revision_id, stop_revision_id,
 
519
                                       stop_rule):
468
520
        """Iterate over an inclusive range of sorted revisions."""
469
521
        rev_iter = iter(merge_sorted_revisions)
470
522
        if start_revision_id is not None:
471
523
            for node in rev_iter:
472
 
                rev_id = node.key[-1]
 
524
                rev_id = node.key
473
525
                if rev_id != start_revision_id:
474
526
                    continue
475
527
                else:
476
528
                    # The decision to include the start or not
477
529
                    # depends on the stop_rule if a stop is provided
478
530
                    # so pop this node back into the iterator
479
 
                    rev_iter = chain(iter([node]), rev_iter)
 
531
                    rev_iter = itertools.chain(iter([node]), rev_iter)
480
532
                    break
481
533
        if stop_revision_id is None:
482
534
            # Yield everything
483
535
            for node in rev_iter:
484
 
                rev_id = node.key[-1]
 
536
                rev_id = node.key
485
537
                yield (rev_id, node.merge_depth, node.revno,
486
538
                       node.end_of_merge)
487
539
        elif stop_rule == 'exclude':
488
540
            for node in rev_iter:
489
 
                rev_id = node.key[-1]
 
541
                rev_id = node.key
490
542
                if rev_id == stop_revision_id:
491
543
                    return
492
544
                yield (rev_id, node.merge_depth, node.revno,
493
545
                       node.end_of_merge)
494
546
        elif stop_rule == 'include':
495
547
            for node in rev_iter:
496
 
                rev_id = node.key[-1]
 
548
                rev_id = node.key
497
549
                yield (rev_id, node.merge_depth, node.revno,
498
550
                       node.end_of_merge)
499
551
                if rev_id == stop_revision_id:
505
557
            ancestors = graph.find_unique_ancestors(start_revision_id,
506
558
                                                    [stop_revision_id])
507
559
            for node in rev_iter:
508
 
                rev_id = node.key[-1]
 
560
                rev_id = node.key
509
561
                if rev_id not in ancestors:
510
562
                    continue
511
563
                yield (rev_id, node.merge_depth, node.revno,
521
573
            reached_stop_revision_id = False
522
574
            revision_id_whitelist = []
523
575
            for node in rev_iter:
524
 
                rev_id = node.key[-1]
 
576
                rev_id = node.key
525
577
                if rev_id == left_parent:
526
578
                    # reached the left parent after the stop_revision
527
579
                    return
528
 
                if (not reached_stop_revision_id or
529
 
                        rev_id in revision_id_whitelist):
 
580
                if (not reached_stop_revision_id
 
581
                        or rev_id in revision_id_whitelist):
530
582
                    yield (rev_id, node.merge_depth, node.revno,
531
 
                       node.end_of_merge)
 
583
                           node.end_of_merge)
532
584
                    if reached_stop_revision_id or rev_id == stop_revision_id:
533
585
                        # only do the merged revs of rev_id from now on
534
586
                        rev = self.repository.get_revision(rev_id)
544
596
        # ancestry. Given the order guaranteed by the merge sort, we will see
545
597
        # uninteresting descendants of the first parent of our tip before the
546
598
        # tip itself.
547
 
        first = rev_iter.next()
 
599
        try:
 
600
            first = next(rev_iter)
 
601
        except StopIteration:
 
602
            return
548
603
        (rev_id, merge_depth, revno, end_of_merge) = first
549
604
        yield first
550
605
        if not merge_depth:
587
642
        """Tell this branch object not to release the physical lock when this
588
643
        object is unlocked.
589
644
 
590
 
        If lock_write doesn't return a token, then this method is not supported.
 
645
        If lock_write doesn't return a token, then this method is not
 
646
        supported.
591
647
        """
592
648
        self.control_files.leave_in_place()
593
649
 
595
651
        """Tell this branch object to release the physical lock when this
596
652
        object is unlocked, even if it didn't originally acquire it.
597
653
 
598
 
        If lock_write doesn't return a token, then this method is not supported.
 
654
        If lock_write doesn't return a token, then this method is not
 
655
        supported.
599
656
        """
600
657
        self.control_files.dont_leave_in_place()
601
658
 
607
664
        """
608
665
        raise errors.UpgradeRequired(self.user_url)
609
666
 
 
667
    def get_append_revisions_only(self):
 
668
        """Whether it is only possible to append revisions to the history.
 
669
        """
 
670
        if not self._format.supports_set_append_revisions_only():
 
671
            return False
 
672
        return self.get_config_stack().get('append_revisions_only')
 
673
 
610
674
    def set_append_revisions_only(self, enabled):
611
675
        if not self._format.supports_set_append_revisions_only():
612
676
            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)
627
 
 
628
 
    @needs_write_lock
629
 
    def fetch(self, from_branch, last_revision=None, pb=None):
 
677
        self.get_config_stack().set('append_revisions_only', enabled)
 
678
 
 
679
    def fetch(self, from_branch, stop_revision=None, limit=None, lossy=False):
630
680
        """Copy revisions from from_branch into this branch.
631
681
 
632
682
        :param from_branch: Where to copy from.
633
 
        :param last_revision: What revision to stop at (None for at the end
 
683
        :param stop_revision: What revision to stop at (None for at the end
634
684
                              of the branch.
635
 
        :param pb: An optional progress bar to use.
 
685
        :param limit: Optional rough limit of revisions to fetch
636
686
        :return: None
637
687
        """
638
 
        if self.base == from_branch.base:
639
 
            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()")
644
 
        from_branch.lock_read()
645
 
        try:
646
 
            if last_revision is None:
647
 
                last_revision = from_branch.last_revision()
648
 
                last_revision = _mod_revision.ensure_null(last_revision)
649
 
            return self.repository.fetch(from_branch.repository,
650
 
                                         revision_id=last_revision,
651
 
                                         pb=pb)
652
 
        finally:
653
 
            from_branch.unlock()
 
688
        with self.lock_write():
 
689
            return InterBranch.get(from_branch, self).fetch(
 
690
                stop_revision, limit=limit, lossy=lossy)
654
691
 
655
692
    def get_bound_location(self):
656
693
        """Return the URL of the branch we are bound to.
665
702
        """
666
703
        raise errors.UpgradeRequired(self.user_url)
667
704
 
668
 
    def get_commit_builder(self, parents, config=None, timestamp=None,
 
705
    def get_commit_builder(self, parents, config_stack=None, timestamp=None,
669
706
                           timezone=None, committer=None, revprops=None,
670
 
                           revision_id=None):
 
707
                           revision_id=None, lossy=False):
671
708
        """Obtain a CommitBuilder for this branch.
672
709
 
673
710
        :param parents: Revision ids of the parents of the new revision.
677
714
        :param committer: Optional committer to set for commit.
678
715
        :param revprops: Optional dictionary of revision properties.
679
716
        :param revision_id: Optional revision id.
 
717
        :param lossy: Whether to discard data that can not be natively
 
718
            represented, when pushing to a foreign VCS
680
719
        """
681
720
 
682
 
        if config is None:
683
 
            config = self.get_config()
 
721
        if config_stack is None:
 
722
            config_stack = self.get_config_stack()
684
723
 
685
 
        return self.repository.get_commit_builder(self, parents, config,
686
 
            timestamp, timezone, committer, revprops, revision_id)
 
724
        return self.repository.get_commit_builder(
 
725
            self, parents, config_stack, timestamp, timezone, committer,
 
726
            revprops, revision_id, lossy)
687
727
 
688
728
    def get_master_branch(self, possible_transports=None):
689
729
        """Return the branch we are bound to.
692
732
        """
693
733
        return None
694
734
 
695
 
    def get_revision_delta(self, revno):
696
 
        """Return the delta for one revision.
697
 
 
698
 
        The delta is relative to its mainline predecessor, or the
699
 
        empty tree for revision 1.
700
 
        """
701
 
        rh = self.revision_history()
702
 
        if not (1 <= revno <= len(rh)):
703
 
            raise errors.InvalidRevisionNumber(revno)
704
 
        return self.repository.get_revision_delta(rh[revno-1])
705
 
 
706
735
    def get_stacked_on_url(self):
707
736
        """Get the URL this branch is stacked against.
708
737
 
712
741
        """
713
742
        raise NotImplementedError(self.get_stacked_on_url)
714
743
 
715
 
    def print_file(self, file, revision_id):
716
 
        """Print `file` to stdout."""
717
 
        raise NotImplementedError(self.print_file)
718
 
 
719
 
    def set_revision_history(self, rev_history):
720
 
        raise NotImplementedError(self.set_revision_history)
721
 
 
722
 
    @needs_write_lock
 
744
    def set_last_revision_info(self, revno, revision_id):
 
745
        """Set the last revision of this branch.
 
746
 
 
747
        The caller is responsible for checking that the revno is correct
 
748
        for this revision id.
 
749
 
 
750
        It may be possible to set the branch last revision to an id not
 
751
        present in the repository.  However, branches can also be
 
752
        configured to check constraints on history, in which case this may not
 
753
        be permitted.
 
754
        """
 
755
        raise NotImplementedError(self.set_last_revision_info)
 
756
 
 
757
    def generate_revision_history(self, revision_id, last_rev=None,
 
758
                                  other_branch=None):
 
759
        """See Branch.generate_revision_history"""
 
760
        with self.lock_write():
 
761
            graph = self.repository.get_graph()
 
762
            (last_revno, last_revid) = self.last_revision_info()
 
763
            known_revision_ids = [
 
764
                (last_revid, last_revno),
 
765
                (_mod_revision.NULL_REVISION, 0),
 
766
                ]
 
767
            if last_rev is not None:
 
768
                if not graph.is_ancestor(last_rev, revision_id):
 
769
                    # our previous tip is not merged into stop_revision
 
770
                    raise errors.DivergedBranches(self, other_branch)
 
771
            revno = graph.find_distance_to_null(
 
772
                revision_id, known_revision_ids)
 
773
            self.set_last_revision_info(revno, revision_id)
 
774
 
723
775
    def set_parent(self, url):
724
776
        """See Branch.set_parent."""
725
777
        # TODO: Maybe delete old location files?
727
779
        # FIXUP this and get_parent in a future branch format bump:
728
780
        # read and rewrite the file. RBC 20060125
729
781
        if url is not None:
730
 
            if isinstance(url, unicode):
 
782
            if isinstance(url, text_type):
731
783
                try:
732
 
                    url = url.encode('ascii')
 
784
                    url.encode('ascii')
733
785
                except UnicodeEncodeError:
734
 
                    raise errors.InvalidURL(url,
735
 
                        "Urls must be 7-bit ascii, "
736
 
                        "use bzrlib.urlutils.escape")
 
786
                    raise urlutils.InvalidURL(
 
787
                        url, "Urls must be 7-bit ascii, "
 
788
                        "use breezy.urlutils.escape")
737
789
            url = urlutils.relative_url(self.base, url)
738
 
        self._set_parent_location(url)
 
790
        with self.lock_write():
 
791
            self._set_parent_location(url)
739
792
 
740
 
    @needs_write_lock
741
793
    def set_stacked_on_url(self, url):
742
794
        """Set the URL this branch is stacked against.
743
795
 
747
799
            stacking.
748
800
        """
749
801
        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)
 
802
            raise UnstackableBranchFormat(self._format, self.user_url)
 
803
        with self.lock_write():
 
804
            # XXX: Changing from one fallback repository to another does not
 
805
            # check that all the data you need is present in the new fallback.
 
806
            # Possibly it should.
 
807
            self._check_stackable_repo()
 
808
            if not url:
 
809
                try:
 
810
                    self.get_stacked_on_url()
 
811
                except (errors.NotStacked, UnstackableBranchFormat,
 
812
                        errors.UnstackableRepositoryFormat):
 
813
                    return
 
814
                self._unstack()
 
815
            else:
 
816
                self._activate_fallback_location(
 
817
                    url, possible_transports=[self.controldir.root_transport])
 
818
            # write this out after the repository is stacked to avoid setting a
 
819
            # stacked config that doesn't work.
 
820
            self._set_config_location('stacked_on_location', url)
767
821
 
768
822
    def _unstack(self):
769
823
        """Change a branch to be unstacked, copying data as needed.
770
 
        
 
824
 
771
825
        Don't call this directly, use set_stacked_on_url(None).
772
826
        """
773
 
        pb = ui.ui_factory.nested_progress_bar()
774
 
        try:
775
 
            pb.update("Unstacking")
 
827
        with ui.ui_factory.nested_progress_bar() as pb:
 
828
            pb.update(gettext("Unstacking"))
776
829
            # The basic approach here is to fetch the tip of the branch,
777
830
            # including all available ghosts, from the existing stacked
778
 
            # repository into a new repository object without the fallbacks. 
 
831
            # repository into a new repository object without the fallbacks.
779
832
            #
780
833
            # XXX: See <https://launchpad.net/bugs/397286> - this may not be
781
834
            # correct for CHKMap repostiories
782
835
            old_repository = self.repository
783
836
            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
 
837
                raise AssertionError(
 
838
                    "can't cope with fallback repositories "
 
839
                    "of %r (fallbacks: %r)" % (
 
840
                        old_repository, old_repository._fallback_repositories))
 
841
            # Open the new repository object.
 
842
            # Repositories don't offer an interface to remove fallback
 
843
            # repositories today; take the conceptually simpler option and just
 
844
            # reopen it.  We reopen it starting from the URL so that we
 
845
            # get a separate connection for RemoteRepositories and can
 
846
            # stream from one of them to the other.  This does mean doing
 
847
            # separate SSH connection setup, but unstacking is not a
 
848
            # common operation so it's tolerable.
 
849
            new_bzrdir = controldir.ControlDir.open(
 
850
                self.controldir.root_transport.base)
 
851
            new_repository = new_bzrdir.find_repository()
 
852
            if new_repository._fallback_repositories:
 
853
                raise AssertionError(
 
854
                    "didn't expect %r to have fallback_repositories"
 
855
                    % (self.repository,))
 
856
            # Replace self.repository with the new repository.
 
857
            # Do our best to transfer the lock state (i.e. lock-tokens and
 
858
            # lock count) of self.repository to the new repository.
 
859
            lock_token = old_repository.lock_write().repository_token
 
860
            self.repository = new_repository
 
861
            if isinstance(self, remote.RemoteBranch):
 
862
                # Remote branches can have a second reference to the old
 
863
                # repository that need to be replaced.
 
864
                if self._real_branch is not None:
 
865
                    self._real_branch.repository = new_repository
 
866
            self.repository.lock_write(token=lock_token)
 
867
            if lock_token is not None:
 
868
                old_repository.leave_lock_in_place()
787
869
            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
 
870
            if lock_token is not None:
 
871
                # XXX: self.repository.leave_lock_in_place() before this
 
872
                # function will not be preserved.  Fortunately that doesn't
 
873
                # affect the current default format (2a), and would be a
 
874
                # corner-case anyway.
 
875
                #  - Andrew Bennetts, 2010/06/30
 
876
                self.repository.dont_leave_lock_in_place()
 
877
            old_lock_count = 0
 
878
            while True:
 
879
                try:
 
880
                    old_repository.unlock()
 
881
                except errors.LockNotHeld:
 
882
                    break
 
883
                old_lock_count += 1
 
884
            if old_lock_count == 0:
 
885
                raise AssertionError(
 
886
                    'old_repository should have been locked at least once.')
 
887
            for i in range(old_lock_count - 1):
807
888
                self.repository.lock_write()
 
889
            # Fetch from the old repository into the new.
 
890
            with old_repository.lock_read():
808
891
                # XXX: If you unstack a branch while it has a working tree
809
892
                # with a pending merge, the pending-merged revisions will no
810
893
                # 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)
 
894
                try:
 
895
                    tags_to_fetch = set(self.tags.get_reverse_tag_dict())
 
896
                except errors.TagsNotSupported:
 
897
                    tags_to_fetch = set()
 
898
                fetch_spec = vf_search.NotInOtherForRevs(
 
899
                    self.repository, old_repository,
 
900
                    required_ids=[self.last_revision()],
 
901
                    if_present_ids=tags_to_fetch, find_ghosts=True).execute()
 
902
                self.repository.fetch(old_repository, fetch_spec=fetch_spec)
830
903
 
831
904
    def _cache_revision_history(self, rev_history):
832
905
        """Set the cached revision history to rev_history.
853
926
        This means the next call to revision_history will need to call
854
927
        _gen_revision_history.
855
928
 
856
 
        This API is semi-public; it only for use by subclasses, all other code
857
 
        should consider it to be private.
 
929
        This API is semi-public; it is only for use by subclasses, all other
 
930
        code should consider it to be private.
858
931
        """
859
932
        self._revision_history_cache = None
860
933
        self._revision_id_to_revno_cache = None
861
934
        self._last_revision_info_cache = None
 
935
        self._master_branch_cache = None
862
936
        self._merge_sorted_revisions_cache = None
863
937
        self._partial_revision_history_cache = []
864
938
        self._partial_revision_id_to_revno_cache = {}
878
952
        """
879
953
        raise NotImplementedError(self._gen_revision_history)
880
954
 
881
 
    @needs_read_lock
882
 
    def revision_history(self):
883
 
        """Return sequence of revision ids on this branch.
884
 
 
885
 
        This method will cache the revision history for as long as it is safe to
886
 
        do so.
887
 
        """
 
955
    def _revision_history(self):
888
956
        if 'evil' in debug.debug_flags:
889
957
            mutter_callsite(3, "revision_history scales with history.")
890
958
        if self._revision_history_cache is not None:
910
978
        """Return last revision id, or NULL_REVISION."""
911
979
        return self.last_revision_info()[1]
912
980
 
913
 
    @needs_read_lock
914
981
    def last_revision_info(self):
915
982
        """Return information about the last revision.
916
983
 
917
984
        :return: A tuple (revno, revision_id).
918
985
        """
919
 
        if self._last_revision_info_cache is None:
920
 
            self._last_revision_info_cache = self._last_revision_info()
921
 
        return self._last_revision_info_cache
922
 
 
923
 
    def _last_revision_info(self):
924
 
        rh = self.revision_history()
925
 
        revno = len(rh)
926
 
        if revno:
927
 
            return (revno, rh[-1])
928
 
        else:
929
 
            return (0, _mod_revision.NULL_REVISION)
930
 
 
931
 
    @deprecated_method(deprecated_in((1, 6, 0)))
932
 
    def missing_revisions(self, other, stop_revision=None):
933
 
        """Return a list of new revisions that would perfectly fit.
934
 
 
935
 
        If self and other have not diverged, return a list of the revisions
936
 
        present in other, but missing from self.
937
 
        """
938
 
        self_history = self.revision_history()
939
 
        self_len = len(self_history)
940
 
        other_history = other.revision_history()
941
 
        other_len = len(other_history)
942
 
        common_index = min(self_len, other_len) -1
943
 
        if common_index >= 0 and \
944
 
            self_history[common_index] != other_history[common_index]:
945
 
            raise errors.DivergedBranches(self, other)
946
 
 
947
 
        if stop_revision is None:
948
 
            stop_revision = other_len
949
 
        else:
950
 
            if stop_revision > other_len:
951
 
                raise errors.NoSuchRevision(self, stop_revision)
952
 
        return other_history[self_len:stop_revision]
953
 
 
954
 
    @needs_write_lock
955
 
    def update_revisions(self, other, stop_revision=None, overwrite=False,
956
 
                         graph=None):
957
 
        """Pull in new perfect-fit revisions.
958
 
 
959
 
        :param other: Another Branch to pull from
960
 
        :param stop_revision: Updated until the given revision
961
 
        :param overwrite: Always set the branch pointer, rather than checking
962
 
            to see if it is a proper descendant.
963
 
        :param graph: A Graph object that can be used to query history
964
 
            information. This can be None.
965
 
        :return: None
966
 
        """
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):
 
986
        with self.lock_read():
 
987
            if self._last_revision_info_cache is None:
 
988
                self._last_revision_info_cache = (
 
989
                    self._read_last_revision_info())
 
990
            return self._last_revision_info_cache
 
991
 
 
992
    def _read_last_revision_info(self):
 
993
        raise NotImplementedError(self._read_last_revision_info)
 
994
 
 
995
    def import_last_revision_info_and_tags(self, source, revno, revid,
 
996
                                           lossy=False):
971
997
        """Set the last revision info, importing from another repo if necessary.
972
998
 
973
999
        This is used by the bound branch code to upload a revision to
974
1000
        the master branch first before updating the tip of the local branch.
 
1001
        Revisions referenced by source's tags are also transferred.
975
1002
 
976
 
        :param source_repo: Source repository to optionally fetch from
 
1003
        :param source: Source branch to optionally fetch from
977
1004
        :param revno: Revision number of the new tip
978
1005
        :param revid: Revision id of the new tip
 
1006
        :param lossy: Whether to discard metadata that can not be
 
1007
            natively represented
 
1008
        :return: Tuple with the new revision number and revision id
 
1009
            (should only be different from the arguments when lossy=True)
979
1010
        """
980
 
        if not self.repository.has_same_location(source_repo):
981
 
            self.repository.fetch(source_repo, revision_id=revid)
 
1011
        if not self.repository.has_same_location(source.repository):
 
1012
            self.fetch(source, revid)
982
1013
        self.set_last_revision_info(revno, revid)
 
1014
        return (revno, revid)
983
1015
 
984
1016
    def revision_id_to_revno(self, revision_id):
985
1017
        """Given a revision id, return its revno"""
986
1018
        if _mod_revision.is_null(revision_id):
987
1019
            return 0
988
 
        history = self.revision_history()
 
1020
        history = self._revision_history()
989
1021
        try:
990
1022
            return history.index(revision_id) + 1
991
1023
        except ValueError:
992
1024
            raise errors.NoSuchRevision(self, revision_id)
993
1025
 
994
 
    @needs_read_lock
995
1026
    def get_rev_id(self, revno, history=None):
996
1027
        """Find the revision id of the specified revno."""
997
 
        if revno == 0:
998
 
            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:
1003
 
            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]
 
1028
        with self.lock_read():
 
1029
            if revno == 0:
 
1030
                return _mod_revision.NULL_REVISION
 
1031
            last_revno, last_revid = self.last_revision_info()
 
1032
            if revno == last_revno:
 
1033
                return last_revid
 
1034
            if revno <= 0 or revno > last_revno:
 
1035
                raise errors.NoSuchRevision(self, revno)
 
1036
            distance_from_last = last_revno - revno
 
1037
            if len(self._partial_revision_history_cache) <= distance_from_last:
 
1038
                self._extend_partial_history(distance_from_last)
 
1039
            return self._partial_revision_history_cache[distance_from_last]
1008
1040
 
1009
 
    @needs_write_lock
1010
1041
    def pull(self, source, overwrite=False, stop_revision=None,
1011
1042
             possible_transports=None, *args, **kwargs):
1012
1043
        """Mirror source into this branch.
1015
1046
 
1016
1047
        :returns: PullResult instance
1017
1048
        """
1018
 
        return InterBranch.get(source, self).pull(overwrite=overwrite,
1019
 
            stop_revision=stop_revision,
 
1049
        return InterBranch.get(source, self).pull(
 
1050
            overwrite=overwrite, stop_revision=stop_revision,
1020
1051
            possible_transports=possible_transports, *args, **kwargs)
1021
1052
 
1022
 
    def push(self, target, overwrite=False, stop_revision=None, *args,
1023
 
        **kwargs):
 
1053
    def push(self, target, overwrite=False, stop_revision=None, lossy=False,
 
1054
             *args, **kwargs):
1024
1055
        """Mirror this branch into target.
1025
1056
 
1026
1057
        This branch is considered to be 'local', having low latency.
1027
1058
        """
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)
 
1059
        return InterBranch.get(self, target).push(
 
1060
            overwrite, stop_revision, lossy, *args, **kwargs)
1051
1061
 
1052
1062
    def basis_tree(self):
1053
1063
        """Return `Tree` object for last revision."""
1066
1076
        # This is an old-format absolute path to a local branch
1067
1077
        # turn it into a url
1068
1078
        if parent.startswith('/'):
1069
 
            parent = urlutils.local_path_to_url(parent.decode('utf8'))
 
1079
            parent = urlutils.local_path_to_url(parent)
1070
1080
        try:
1071
1081
            return urlutils.join(self.base[:-1], parent)
1072
 
        except errors.InvalidURLJoin, e:
 
1082
        except urlutils.InvalidURLJoin:
1073
1083
            raise errors.InaccessibleParent(parent, self.user_url)
1074
1084
 
1075
1085
    def _get_parent_location(self):
1078
1088
    def _set_config_location(self, name, url, config=None,
1079
1089
                             make_relative=False):
1080
1090
        if config is None:
1081
 
            config = self.get_config()
 
1091
            config = self.get_config_stack()
1082
1092
        if url is None:
1083
1093
            url = ''
1084
1094
        elif make_relative:
1085
1095
            url = urlutils.relative_url(self.base, url)
1086
 
        config.set_user_option(name, url, warn_masked=True)
 
1096
        config.set(name, url)
1087
1097
 
1088
1098
    def _get_config_location(self, name, config=None):
1089
1099
        if config is None:
1090
 
            config = self.get_config()
1091
 
        location = config.get_user_option(name)
 
1100
            config = self.get_config_stack()
 
1101
        location = config.get(name)
1092
1102
        if location == '':
1093
1103
            location = None
1094
1104
        return location
1095
1105
 
1096
1106
    def get_child_submit_format(self):
1097
1107
        """Return the preferred format of submissions to this branch."""
1098
 
        return self.get_config().get_user_option("child_submit_format")
 
1108
        return self.get_config_stack().get('child_submit_format')
1099
1109
 
1100
1110
    def get_submit_branch(self):
1101
1111
        """Return the submit location of the branch.
1104
1114
        pattern is that the user can override it by specifying a
1105
1115
        location.
1106
1116
        """
1107
 
        return self.get_config().get_user_option('submit_branch')
 
1117
        return self.get_config_stack().get('submit_branch')
1108
1118
 
1109
1119
    def set_submit_branch(self, location):
1110
1120
        """Return the submit location of the branch.
1113
1123
        pattern is that the user can override it by specifying a
1114
1124
        location.
1115
1125
        """
1116
 
        self.get_config().set_user_option('submit_branch', location,
1117
 
            warn_masked=True)
 
1126
        self.get_config_stack().set('submit_branch', location)
1118
1127
 
1119
1128
    def get_public_branch(self):
1120
1129
        """Return the public location of the branch.
1133
1142
        self._set_config_location('public_branch', location)
1134
1143
 
1135
1144
    def get_push_location(self):
1136
 
        """Return the None or the location to push this branch to."""
1137
 
        push_loc = self.get_config().get_user_option('push_location')
1138
 
        return push_loc
 
1145
        """Return None or the location to push this branch to."""
 
1146
        return self.get_config_stack().get('push_location')
1139
1147
 
1140
1148
    def set_push_location(self, location):
1141
1149
        """Set a new push location for this branch."""
1163
1171
        for hook in hooks:
1164
1172
            hook(params)
1165
1173
 
1166
 
    @needs_write_lock
1167
1174
    def update(self):
1168
1175
        """Synchronise this branch with the master branch if any.
1169
1176
 
1187
1194
        if revno < 1 or revno > self.revno():
1188
1195
            raise errors.InvalidRevisionNumber(revno)
1189
1196
 
1190
 
    @needs_read_lock
1191
 
    def clone(self, to_bzrdir, revision_id=None, repository_policy=None):
1192
 
        """Clone this branch into to_bzrdir preserving all semantic values.
 
1197
    def clone(self, to_controldir, revision_id=None, repository_policy=None,
 
1198
              tag_selector=None):
 
1199
        """Clone this branch into to_controldir preserving all semantic values.
1193
1200
 
1194
1201
        Most API users will want 'create_clone_on_transport', which creates a
1195
1202
        new bzrdir and branch on the fly.
1197
1204
        revision_id: if not None, the revision history in the new branch will
1198
1205
                     be truncated to end with revision_id.
1199
1206
        """
1200
 
        result = to_bzrdir.create_branch()
1201
 
        result.lock_write()
1202
 
        try:
 
1207
        result = to_controldir.create_branch()
 
1208
        with self.lock_read(), result.lock_write():
1203
1209
            if repository_policy is not None:
1204
1210
                repository_policy.configure_branch(result)
1205
 
            self.copy_content_into(result, revision_id=revision_id)
1206
 
        finally:
1207
 
            result.unlock()
 
1211
            self.copy_content_into(
 
1212
                result, revision_id=revision_id, tag_selector=tag_selector)
1208
1213
        return result
1209
1214
 
1210
 
    @needs_read_lock
1211
 
    def sprout(self, to_bzrdir, revision_id=None, repository_policy=None):
1212
 
        """Create a new line of development from the branch, into to_bzrdir.
 
1215
    def sprout(self, to_controldir, revision_id=None, repository_policy=None,
 
1216
               repository=None, lossy=False, tag_selector=None):
 
1217
        """Create a new line of development from the branch, into to_controldir.
1213
1218
 
1214
 
        to_bzrdir controls the branch format.
 
1219
        to_controldir controls the branch format.
1215
1220
 
1216
1221
        revision_id: if not None, the revision history in the new branch will
1217
1222
                     be truncated to end with revision_id.
1218
1223
        """
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:
 
1224
        if (repository_policy is not None
 
1225
                and repository_policy.requires_stacking()):
 
1226
            to_controldir._format.require_stacking(_skip_repo=True)
 
1227
        result = to_controldir.create_branch(repository=repository)
 
1228
        if lossy:
 
1229
            raise errors.LossyPushToSameVCS(self, result)
 
1230
        with self.lock_read(), result.lock_write():
1225
1231
            if repository_policy is not None:
1226
1232
                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()
 
1233
            self.copy_content_into(
 
1234
                result, revision_id=revision_id, tag_selector=tag_selector)
 
1235
            master_url = self.get_bound_location()
 
1236
            if master_url is None:
 
1237
                result.set_parent(self.user_url)
 
1238
            else:
 
1239
                result.set_parent(master_url)
1231
1240
        return result
1232
1241
 
1233
1242
    def _synchronize_history(self, destination, revision_id):
1248
1257
        else:
1249
1258
            graph = self.repository.get_graph()
1250
1259
            try:
1251
 
                revno = graph.find_distance_to_null(revision_id, 
1252
 
                    [(source_revision_id, source_revno)])
 
1260
                revno = graph.find_distance_to_null(
 
1261
                    revision_id, [(source_revision_id, source_revno)])
1253
1262
            except errors.GhostRevisionsHaveNoRevno:
1254
1263
                # Default to 1, if we can't find anything else
1255
1264
                revno = 1
1256
1265
        destination.set_last_revision_info(revno, revision_id)
1257
1266
 
1258
 
    @needs_read_lock
1259
 
    def copy_content_into(self, destination, revision_id=None):
 
1267
    def copy_content_into(self, destination, revision_id=None, tag_selector=None):
1260
1268
        """Copy the content of self into destination.
1261
1269
 
1262
1270
        revision_id: if not None, the revision history in the new branch will
1263
1271
                     be truncated to end with revision_id.
 
1272
        tag_selector: Optional callback that receives a tag name
 
1273
            and should return a boolean to indicate whether a tag should be copied
1264
1274
        """
1265
 
        self.update_references(destination)
1266
 
        self._synchronize_history(destination, revision_id)
1267
 
        try:
1268
 
            parent = self.get_parent()
1269
 
        except errors.InaccessibleParent, e:
1270
 
            mutter('parent was not accessible to copy: %s', e)
1271
 
        else:
1272
 
            if parent:
1273
 
                destination.set_parent(parent)
1274
 
        if self._push_should_merge_tags():
1275
 
            self.tags.merge_to(destination.tags)
 
1275
        return InterBranch.get(self, destination).copy_content_into(
 
1276
            revision_id=revision_id, tag_selector=tag_selector)
1276
1277
 
1277
1278
    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)
 
1279
        if not self._format.supports_reference_locations:
 
1280
            return
 
1281
        return InterBranch.get(self, target).update_references()
1293
1282
 
1294
 
    @needs_read_lock
1295
1283
    def check(self, refs):
1296
1284
        """Check consistency of the branch.
1297
1285
 
1305
1293
            branch._get_check_refs()
1306
1294
        :return: A BranchCheckResult.
1307
1295
        """
1308
 
        result = BranchCheckResult(self)
1309
 
        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
 
1296
        with self.lock_read():
 
1297
            result = BranchCheckResult(self)
 
1298
            last_revno, last_revision_id = self.last_revision_info()
 
1299
            actual_revno = refs[('lefthand-distance', last_revision_id)]
 
1300
            if actual_revno != last_revno:
 
1301
                result.errors.append(errors.BzrCheckError(
 
1302
                    'revno does not match len(mainline) %s != %s' % (
 
1303
                        last_revno, actual_revno)))
 
1304
            # TODO: We should probably also check that self.revision_history
 
1305
            # matches the repository for older branch formats.
 
1306
            # If looking for the code that cross-checks repository parents
 
1307
            # against the Graph.iter_lefthand_ancestry output, that is now a
 
1308
            # repository specific check.
 
1309
            return result
1321
1310
 
1322
 
    def _get_checkout_format(self):
 
1311
    def _get_checkout_format(self, lightweight=False):
1323
1312
        """Return the most suitable metadir for a checkout of this branch.
1324
1313
        Weaves are used if this branch's repository uses weaves.
1325
1314
        """
1326
 
        if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):
1327
 
            from bzrlib.repofmt import weaverepo
1328
 
            format = bzrdir.BzrDirMetaFormat1()
1329
 
            format.repository_format = weaverepo.RepositoryFormat7()
1330
 
        else:
1331
 
            format = self.repository.bzrdir.checkout_metadir()
1332
 
            format.set_branch_format(self._format)
 
1315
        format = self.repository.controldir.checkout_metadir()
 
1316
        format.set_branch_format(self._format)
1333
1317
        return format
1334
1318
 
1335
1319
    def create_clone_on_transport(self, to_transport, revision_id=None,
1336
 
        stacked_on=None, create_prefix=False, use_existing_dir=False):
 
1320
                                  stacked_on=None, create_prefix=False,
 
1321
                                  use_existing_dir=False, no_tree=None,
 
1322
                                  tag_selector=None):
1337
1323
        """Create a clone of this branch and its bzrdir.
1338
1324
 
1339
1325
        :param to_transport: The transport to clone onto.
1346
1332
        """
1347
1333
        # XXX: Fix the bzrdir API to allow getting the branch back from the
1348
1334
        # clone call. Or something. 20090224 RBC/spiv.
 
1335
        # XXX: Should this perhaps clone colocated branches as well,
 
1336
        # rather than just the default branch? 20100319 JRV
1349
1337
        if revision_id is None:
1350
1338
            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)
 
1339
        dir_to = self.controldir.clone_on_transport(
 
1340
            to_transport, revision_id=revision_id, stacked_on=stacked_on,
 
1341
            create_prefix=create_prefix, use_existing_dir=use_existing_dir,
 
1342
            no_tree=no_tree, tag_selector=tag_selector)
1354
1343
        return dir_to.open_branch()
1355
1344
 
1356
1345
    def create_checkout(self, to_location, revision_id=None,
1357
1346
                        lightweight=False, accelerator_tree=None,
1358
 
                        hardlink=False):
 
1347
                        hardlink=False, recurse_nested=True):
1359
1348
        """Create a checkout of a branch.
1360
1349
 
1361
1350
        :param to_location: The url to produce the checkout at
1362
1351
        :param revision_id: The revision to check out
1363
1352
        :param lightweight: If True, produce a lightweight checkout, otherwise,
1364
 
        produce a bound branch (heavyweight checkout)
 
1353
            produce a bound branch (heavyweight checkout)
1365
1354
        :param accelerator_tree: A tree which can be used for retrieving file
1366
1355
            contents more quickly than the revision tree, i.e. a workingtree.
1367
1356
            The revision tree will be used for cases where accelerator_tree's
1368
1357
            content is different.
1369
1358
        :param hardlink: If true, hard-link files from accelerator_tree,
1370
1359
            where possible.
 
1360
        :param recurse_nested: Whether to recurse into nested trees
1371
1361
        :return: The tree of the created checkout
1372
1362
        """
1373
1363
        t = transport.get_transport(to_location)
1374
1364
        t.ensure_base()
 
1365
        format = self._get_checkout_format(lightweight=lightweight)
 
1366
        try:
 
1367
            checkout = format.initialize_on_transport(t)
 
1368
        except errors.AlreadyControlDirError:
 
1369
            # It's fine if the control directory already exists,
 
1370
            # as long as there is no existing branch and working tree.
 
1371
            checkout = controldir.ControlDir.open_from_transport(t)
 
1372
            try:
 
1373
                checkout.open_branch()
 
1374
            except errors.NotBranchError:
 
1375
                pass
 
1376
            else:
 
1377
                raise errors.AlreadyControlDirError(t.base)
 
1378
            if (checkout.control_transport.base
 
1379
                    == self.controldir.control_transport.base):
 
1380
                # When checking out to the same control directory,
 
1381
                # always create a lightweight checkout
 
1382
                lightweight = True
 
1383
 
1375
1384
        if lightweight:
1376
 
            format = self._get_checkout_format()
1377
 
            checkout = format.initialize_on_transport(t)
1378
 
            from_branch = BranchReferenceFormat().initialize(checkout, 
1379
 
                target_branch=self)
 
1385
            from_branch = checkout.set_branch_reference(target_branch=self)
1380
1386
        else:
1381
 
            format = self._get_checkout_format()
1382
 
            checkout_branch = bzrdir.BzrDir.create_branch_convenience(
1383
 
                to_location, force_new_tree=False, format=format)
1384
 
            checkout = checkout_branch.bzrdir
 
1387
            policy = checkout.determine_repository_policy()
 
1388
            policy.acquire_repository()
 
1389
            checkout_branch = checkout.create_branch()
1385
1390
            checkout_branch.bind(self)
1386
1391
            # pull up to the specified revision_id to set the initial
1387
1392
            # branch tip correctly, and seed it with history.
1388
1393
            checkout_branch.pull(self, stop_revision=revision_id)
1389
 
            from_branch=None
 
1394
            from_branch = None
1390
1395
        tree = checkout.create_workingtree(revision_id,
1391
1396
                                           from_branch=from_branch,
1392
1397
                                           accelerator_tree=accelerator_tree,
1393
1398
                                           hardlink=hardlink)
1394
1399
        basis_tree = tree.basis_tree()
1395
 
        basis_tree.lock_read()
1396
 
        try:
1397
 
            for path, file_id in basis_tree.iter_references():
1398
 
                reference_parent = self.reference_parent(file_id, path)
1399
 
                reference_parent.create_checkout(tree.abspath(path),
1400
 
                    basis_tree.get_reference_revision(file_id, path),
1401
 
                    lightweight)
1402
 
        finally:
1403
 
            basis_tree.unlock()
 
1400
        with basis_tree.lock_read():
 
1401
            for path in basis_tree.iter_references():
 
1402
                reference_parent = tree.reference_parent(path)
 
1403
                if reference_parent is None:
 
1404
                    warning('Branch location for %s unknown.', path)
 
1405
                    continue
 
1406
                reference_parent.create_checkout(
 
1407
                    tree.abspath(path),
 
1408
                    basis_tree.get_reference_revision(path), lightweight)
1404
1409
        return tree
1405
1410
 
1406
 
    @needs_write_lock
1407
1411
    def reconcile(self, thorough=True):
1408
 
        """Make sure the data stored in this branch is consistent."""
1409
 
        from bzrlib.reconcile import BranchReconciler
1410
 
        reconciler = BranchReconciler(self, thorough=thorough)
1411
 
        reconciler.reconcile()
1412
 
        return reconciler
 
1412
        """Make sure the data stored in this branch is consistent.
1413
1413
 
1414
 
    def reference_parent(self, file_id, path, possible_transports=None):
1415
 
        """Return the parent branch for a tree-reference file_id
1416
 
        :param file_id: The file_id of the tree reference
1417
 
        :param path: The path of the file_id in the tree
1418
 
        :return: A branch associated with the file_id
 
1414
        :return: A `ReconcileResult` object.
1419
1415
        """
1420
 
        # FIXME should provide multiple branches, based on config
1421
 
        return Branch.open(self.bzrdir.root_transport.clone(path).base,
1422
 
                           possible_transports=possible_transports)
 
1416
        raise NotImplementedError(self.reconcile)
1423
1417
 
1424
1418
    def supports_tags(self):
1425
1419
        return self._format.supports_tags()
1461
1455
        :returns: One of: 'a_descends_from_b', 'b_descends_from_a', 'diverged'
1462
1456
        """
1463
1457
        heads = graph.heads([revision_a, revision_b])
1464
 
        if heads == set([revision_b]):
 
1458
        if heads == {revision_b}:
1465
1459
            return 'b_descends_from_a'
1466
 
        elif heads == set([revision_a, revision_b]):
 
1460
        elif heads == {revision_a, revision_b}:
1467
1461
            # These branches have diverged
1468
1462
            return 'diverged'
1469
 
        elif heads == set([revision_a]):
 
1463
        elif heads == {revision_a}:
1470
1464
            return 'a_descends_from_b'
1471
1465
        else:
1472
1466
            raise AssertionError("invalid heads: %r" % (heads,))
1473
1467
 
1474
 
 
1475
 
class BranchFormat(object):
 
1468
    def heads_to_fetch(self):
 
1469
        """Return the heads that must and that should be fetched to copy this
 
1470
        branch into another repo.
 
1471
 
 
1472
        :returns: a 2-tuple of (must_fetch, if_present_fetch).  must_fetch is a
 
1473
            set of heads that must be fetched.  if_present_fetch is a set of
 
1474
            heads that must be fetched if present, but no error is necessary if
 
1475
            they are not present.
 
1476
        """
 
1477
        # For bzr native formats must_fetch is just the tip, and
 
1478
        # if_present_fetch are the tags.
 
1479
        must_fetch = {self.last_revision()}
 
1480
        if_present_fetch = set()
 
1481
        if self.get_config_stack().get('branch.fetch_tags'):
 
1482
            try:
 
1483
                if_present_fetch = set(self.tags.get_reverse_tag_dict())
 
1484
            except errors.TagsNotSupported:
 
1485
                pass
 
1486
        must_fetch.discard(_mod_revision.NULL_REVISION)
 
1487
        if_present_fetch.discard(_mod_revision.NULL_REVISION)
 
1488
        return must_fetch, if_present_fetch
 
1489
 
 
1490
    def create_memorytree(self):
 
1491
        """Create a memory tree for this branch.
 
1492
 
 
1493
        :return: An in-memory MutableTree instance
 
1494
        """
 
1495
        return memorytree.MemoryTree.create_on_branch(self)
 
1496
 
 
1497
 
 
1498
class BranchFormat(controldir.ControlComponentFormat):
1476
1499
    """An encapsulation of the initialization and open routines for a format.
1477
1500
 
1478
1501
    Formats provide three things:
1479
1502
     * An initialization routine,
1480
 
     * a format string,
 
1503
     * a format description
1481
1504
     * an open routine.
1482
1505
 
1483
1506
    Formats are placed in an dict by their format string for reference
1484
 
    during branch opening. Its not required that these be instances, they
 
1507
    during branch opening. It's not required that these be instances, they
1485
1508
    can be classes themselves with class methods - it simply depends on
1486
1509
    whether state is needed for a given format or not.
1487
1510
 
1490
1513
    object will be created every time regardless.
1491
1514
    """
1492
1515
 
1493
 
    _default_format = None
1494
 
    """The default format used for new branches."""
1495
 
 
1496
 
    _formats = {}
1497
 
    """The known formats."""
1498
 
 
1499
 
    can_set_append_revisions_only = True
1500
 
 
1501
1516
    def __eq__(self, other):
1502
1517
        return self.__class__ is other.__class__
1503
1518
 
1504
1519
    def __ne__(self, other):
1505
1520
        return not (self == other)
1506
1521
 
1507
 
    @classmethod
1508
 
    def find_format(klass, a_bzrdir, name=None):
1509
 
        """Return the format for the branch object in a_bzrdir."""
1510
 
        try:
1511
 
            transport = a_bzrdir.get_branch_transport(None, name=name)
1512
 
            format_string = transport.get_bytes("format")
1513
 
            return klass._formats[format_string]
1514
 
        except errors.NoSuchFile:
1515
 
            raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1516
 
        except KeyError:
1517
 
            raise errors.UnknownFormatError(format=format_string, kind='branch')
1518
 
 
1519
 
    @classmethod
1520
 
    def get_default_format(klass):
1521
 
        """Return the current default format."""
1522
 
        return klass._default_format
1523
 
 
1524
 
    def get_reference(self, a_bzrdir):
1525
 
        """Get the target reference of the branch in a_bzrdir.
 
1522
    def get_reference(self, controldir, name=None):
 
1523
        """Get the target reference of the branch in controldir.
1526
1524
 
1527
1525
        format probing must have been completed before calling
1528
1526
        this method - it is assumed that the format of the branch
1529
 
        in a_bzrdir is correct.
 
1527
        in controldir is correct.
1530
1528
 
1531
 
        :param a_bzrdir: The bzrdir to get the branch data from.
 
1529
        :param controldir: The controldir to get the branch data from.
 
1530
        :param name: Name of the colocated branch to fetch
1532
1531
        :return: None if the branch is not a reference branch.
1533
1532
        """
1534
1533
        return None
1535
1534
 
1536
1535
    @classmethod
1537
 
    def set_reference(self, a_bzrdir, to_branch):
1538
 
        """Set the target reference of the branch in a_bzrdir.
 
1536
    def set_reference(self, controldir, name, to_branch):
 
1537
        """Set the target reference of the branch in controldir.
1539
1538
 
1540
1539
        format probing must have been completed before calling
1541
1540
        this method - it is assumed that the format of the branch
1542
 
        in a_bzrdir is correct.
 
1541
        in controldir is correct.
1543
1542
 
1544
 
        :param a_bzrdir: The bzrdir to set the branch reference for.
 
1543
        :param controldir: The controldir to set the branch reference for.
 
1544
        :param name: Name of colocated branch to set, None for default
1545
1545
        :param to_branch: branch that the checkout is to reference
1546
1546
        """
1547
1547
        raise NotImplementedError(self.set_reference)
1548
1548
 
1549
 
    def get_format_string(self):
1550
 
        """Return the ASCII format string that identifies this format."""
1551
 
        raise NotImplementedError(self.get_format_string)
1552
 
 
1553
1549
    def get_format_description(self):
1554
1550
        """Return the short format description for this format."""
1555
1551
        raise NotImplementedError(self.get_format_description)
1556
1552
 
1557
 
    def _run_post_branch_init_hooks(self, a_bzrdir, name, branch):
 
1553
    def _run_post_branch_init_hooks(self, controldir, name, branch):
1558
1554
        hooks = Branch.hooks['post_branch_init']
1559
1555
        if not hooks:
1560
1556
            return
1561
 
        params = BranchInitHookParams(self, a_bzrdir, name, branch)
 
1557
        params = BranchInitHookParams(self, controldir, name, branch)
1562
1558
        for hook in hooks:
1563
1559
            hook(params)
1564
1560
 
1565
 
    def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
1566
 
                           lock_type='metadir', set_format=True):
1567
 
        """Initialize a branch in a bzrdir, with specified files
1568
 
 
1569
 
        :param a_bzrdir: The bzrdir to initialize the branch in
1570
 
        :param utf8_files: The files to create as a list of
1571
 
            (filename, content) tuples
1572
 
        :param name: Name of colocated branch to create, if any
1573
 
        :param set_format: If True, set the format with
1574
 
            self.get_format_string.  (BzrBranch4 has its format set
1575
 
            elsewhere)
1576
 
        :return: a branch in this format
1577
 
        """
1578
 
        mutter('creating branch %r in %s', self, a_bzrdir.user_url)
1579
 
        branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1580
 
        lock_map = {
1581
 
            'metadir': ('lock', lockdir.LockDir),
1582
 
            'branch4': ('branch-lock', lockable_files.TransportLock),
1583
 
        }
1584
 
        lock_name, lock_class = lock_map[lock_type]
1585
 
        control_files = lockable_files.LockableFiles(branch_transport,
1586
 
            lock_name, lock_class)
1587
 
        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
1596
 
        if set_format:
1597
 
            utf8_files += [('format', self.get_format_string())]
1598
 
        try:
1599
 
            for (filename, content) in utf8_files:
1600
 
                branch_transport.put_bytes(
1601
 
                    filename, content,
1602
 
                    mode=a_bzrdir._get_file_mode())
1603
 
        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
1609
 
 
1610
 
    def initialize(self, a_bzrdir, name=None):
1611
 
        """Create a branch of this format in a_bzrdir.
1612
 
        
 
1561
    def initialize(self, controldir, name=None, repository=None,
 
1562
                   append_revisions_only=None):
 
1563
        """Create a branch of this format in controldir.
 
1564
 
1613
1565
        :param name: Name of the colocated branch to create.
1614
1566
        """
1615
1567
        raise NotImplementedError(self.initialize)
1635
1587
        Note that it is normal for branch to be a RemoteBranch when using tags
1636
1588
        on a RemoteBranch.
1637
1589
        """
1638
 
        return DisabledTags(branch)
 
1590
        return _mod_tag.DisabledTags(branch)
1639
1591
 
1640
1592
    def network_name(self):
1641
1593
        """A simple byte string uniquely identifying this format for RPC calls.
1647
1599
        """
1648
1600
        raise NotImplementedError(self.network_name)
1649
1601
 
1650
 
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
1651
 
        """Return the branch object for a_bzrdir
 
1602
    def open(self, controldir, name=None, _found=False, ignore_fallbacks=False,
 
1603
             found_repository=None, possible_transports=None):
 
1604
        """Return the branch object for controldir.
1652
1605
 
1653
 
        :param a_bzrdir: A BzrDir that contains a branch.
 
1606
        :param controldir: A ControlDir that contains a branch.
1654
1607
        :param name: Name of colocated branch to open
1655
1608
        :param _found: a private parameter, do not use it. It is used to
1656
1609
            indicate if format probing has already be done.
1659
1612
        """
1660
1613
        raise NotImplementedError(self.open)
1661
1614
 
1662
 
    @classmethod
1663
 
    def register_format(klass, format):
1664
 
        """Register a metadir format."""
1665
 
        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
 
 
1670
 
    @classmethod
1671
 
    def set_default_format(klass, format):
1672
 
        klass._default_format = format
1673
 
 
1674
1615
    def supports_set_append_revisions_only(self):
1675
1616
        """True if this format supports set_append_revisions_only."""
1676
1617
        return False
1679
1620
        """True if this format records a stacked-on branch."""
1680
1621
        return False
1681
1622
 
1682
 
    @classmethod
1683
 
    def unregister_format(klass, format):
1684
 
        del klass._formats[format.get_format_string()]
 
1623
    def supports_leaving_lock(self):
 
1624
        """True if this format supports leaving locks in place."""
 
1625
        return False  # by default
1685
1626
 
1686
1627
    def __str__(self):
1687
1628
        return self.get_format_description().rstrip()
1690
1631
        """True if this format supports tags stored in the branch"""
1691
1632
        return False  # by default
1692
1633
 
 
1634
    def tags_are_versioned(self):
 
1635
        """Whether the tag container for this branch versions tags."""
 
1636
        return False
 
1637
 
 
1638
    def supports_tags_referencing_ghosts(self):
 
1639
        """True if tags can reference ghost revisions."""
 
1640
        return True
 
1641
 
 
1642
    def supports_store_uncommitted(self):
 
1643
        """True if uncommitted changes can be stored in this branch."""
 
1644
        return True
 
1645
 
 
1646
    def stores_revno(self):
 
1647
        """True if this branch format store revision numbers."""
 
1648
        return True
 
1649
 
1693
1650
 
1694
1651
class BranchHooks(Hooks):
1695
1652
    """A dictionary mapping hook name to a list of callables for branch hooks.
1696
1653
 
1697
 
    e.g. ['set_rh'] Is the list of items to be called when the
1698
 
    set_revision_history function is invoked.
 
1654
    e.g. ['post_push'] Is the list of items to be called when the
 
1655
    push function is invoked.
1699
1656
    """
1700
1657
 
1701
1658
    def __init__(self):
1704
1661
        These are all empty initially, because by default nothing should get
1705
1662
        notified.
1706
1663
        """
1707
 
        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',
 
1664
        Hooks.__init__(self, "breezy.branch", "Branch.hooks")
 
1665
        self.add_hook(
 
1666
            'open',
1715
1667
            "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',
 
1668
            "branch is opened.", (1, 8))
 
1669
        self.add_hook(
 
1670
            'post_push',
1718
1671
            "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',
 
1672
            "with a breezy.branch.BranchPushResult object and only runs in "
 
1673
            "the bzr client.", (0, 15))
 
1674
        self.add_hook(
 
1675
            'post_pull',
1722
1676
            "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 "
 
1677
            "with a breezy.branch.PullResult object and only runs in the "
 
1678
            "bzr client.", (0, 15))
 
1679
        self.add_hook(
 
1680
            'pre_commit',
 
1681
            "Called after a commit is calculated but before it is "
1727
1682
            "completed. pre_commit is called with (local, master, old_revno, "
1728
1683
            "old_revid, future_revno, future_revid, tree_delta, future_tree"
1729
1684
            "). old_revid is NULL_REVISION for the first commit to a branch, "
1731
1686
            "basis revision. hooks MUST NOT modify this delta. "
1732
1687
            " future_tree is an in-memory tree obtained from "
1733
1688
            "CommitBuilder.revision_tree() and hooks MUST NOT modify this "
1734
 
            "tree.", (0,91), None))
1735
 
        self.create_hook(HookPoint('post_commit',
 
1689
            "tree.", (0, 91))
 
1690
        self.add_hook(
 
1691
            'post_commit',
1736
1692
            "Called in the bzr client after a commit has completed. "
1737
1693
            "post_commit is called with (local, master, old_revno, old_revid, "
1738
1694
            "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',
 
1695
            "commit to a branch.", (0, 15))
 
1696
        self.add_hook(
 
1697
            'post_uncommit',
1741
1698
            "Called in the bzr client after an uncommit completes. "
1742
1699
            "post_uncommit is called with (local, master, old_revno, "
1743
1700
            "old_revid, new_revno, new_revid) where local is the local branch "
1744
1701
            "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',
 
1702
            "receives new_revno of 0, new_revid of None.", (0, 15))
 
1703
        self.add_hook(
 
1704
            'pre_change_branch_tip',
1747
1705
            "Called in bzr client and server before a change to the tip of a "
1748
1706
            "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',
 
1707
            "breezy.branch.ChangeBranchTipParams. Note that push, pull, "
 
1708
            "commit, uncommit will all trigger this hook.", (1, 6))
 
1709
        self.add_hook(
 
1710
            'post_change_branch_tip',
1752
1711
            "Called in bzr client and server after a change to the tip of a "
1753
1712
            "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',
 
1713
            "breezy.branch.ChangeBranchTipParams. Note that push, pull, "
 
1714
            "commit, uncommit will all trigger this hook.", (1, 4))
 
1715
        self.add_hook(
 
1716
            'transform_fallback_location',
1757
1717
            "Called when a stacked branch is activating its fallback "
1758
1718
            "locations. transform_fallback_location is called with (branch, "
1759
1719
            "url), and should return a new url. Returning the same url "
1764
1724
            "fallback locations have not been activated. When there are "
1765
1725
            "multiple hooks installed for transform_fallback_location, "
1766
1726
            "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."
 
1727
            "The order is however undefined.", (1, 9))
 
1728
        self.add_hook(
 
1729
            'automatic_tag_name',
 
1730
            "Called to determine an automatic tag name for a revision. "
1770
1731
            "automatic_tag_name is called with (branch, revision_id) and "
1771
1732
            "should return a tag name or None if no tag name could be "
1772
1733
            "determined. The first non-None tag name returned will be used.",
1773
 
            (2, 2), None))
1774
 
        self.create_hook(HookPoint('post_branch_init',
 
1734
            (2, 2))
 
1735
        self.add_hook(
 
1736
            'post_branch_init',
1775
1737
            "Called after new branch initialization completes. "
1776
1738
            "post_branch_init is called with a "
1777
 
            "bzrlib.branch.BranchInitHookParams. "
 
1739
            "breezy.branch.BranchInitHookParams. "
1778
1740
            "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',
 
1741
            "lightweight) will all trigger this hook.", (2, 2))
 
1742
        self.add_hook(
 
1743
            'post_switch',
1781
1744
            "Called after a checkout switches branch. "
1782
1745
            "post_switch is called with a "
1783
 
            "bzrlib.branch.SwitchHookParams.", (2, 2), None))
1784
 
 
 
1746
            "breezy.branch.SwitchHookParams.", (2, 2))
1785
1747
 
1786
1748
 
1787
1749
# install the default hooks into the Branch class.
1789
1751
 
1790
1752
 
1791
1753
class ChangeBranchTipParams(object):
1792
 
    """Object holding parameters passed to *_change_branch_tip hooks.
 
1754
    """Object holding parameters passed to `*_change_branch_tip` hooks.
1793
1755
 
1794
1756
    There are 5 fields that hooks may wish to access:
1795
1757
 
1827
1789
 
1828
1790
 
1829
1791
class BranchInitHookParams(object):
1830
 
    """Object holding parameters passed to *_branch_init hooks.
 
1792
    """Object holding parameters passed to `*_branch_init` hooks.
1831
1793
 
1832
1794
    There are 4 fields that hooks may wish to access:
1833
1795
 
1834
1796
    :ivar format: the branch format
1835
 
    :ivar bzrdir: the BzrDir where the branch will be/has been initialized
 
1797
    :ivar bzrdir: the ControlDir where the branch will be/has been initialized
1836
1798
    :ivar name: name of colocated branch, if any (or None)
1837
1799
    :ivar branch: the branch created
1838
1800
 
1841
1803
    branch, which refer to the original branch.
1842
1804
    """
1843
1805
 
1844
 
    def __init__(self, format, a_bzrdir, name, branch):
 
1806
    def __init__(self, format, controldir, name, branch):
1845
1807
        """Create a group of BranchInitHook parameters.
1846
1808
 
1847
1809
        :param format: the branch format
1848
 
        :param a_bzrdir: the BzrDir where the branch will be/has been
 
1810
        :param controldir: the ControlDir where the branch will be/has been
1849
1811
            initialized
1850
1812
        :param name: name of colocated branch, if any (or None)
1851
1813
        :param branch: the branch created
1855
1817
        in branch, which refer to the original branch.
1856
1818
        """
1857
1819
        self.format = format
1858
 
        self.bzrdir = a_bzrdir
 
1820
        self.controldir = controldir
1859
1821
        self.name = name
1860
1822
        self.branch = branch
1861
1823
 
1863
1825
        return self.__dict__ == other.__dict__
1864
1826
 
1865
1827
    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)
 
1828
        return "<%s of %s>" % (self.__class__.__name__, self.branch)
1872
1829
 
1873
1830
 
1874
1831
class SwitchHookParams(object):
1875
 
    """Object holding parameters passed to *_switch hooks.
 
1832
    """Object holding parameters passed to `*_switch` hooks.
1876
1833
 
1877
1834
    There are 4 fields that hooks may wish to access:
1878
1835
 
1879
 
    :ivar control_dir: BzrDir of the checkout to change
 
1836
    :ivar control_dir: ControlDir of the checkout to change
1880
1837
    :ivar to_branch: branch that the checkout is to reference
1881
1838
    :ivar force: skip the check for local commits in a heavy checkout
1882
1839
    :ivar revision_id: revision ID to switch to (or None)
1885
1842
    def __init__(self, control_dir, to_branch, force, revision_id):
1886
1843
        """Create a group of SwitchHook parameters.
1887
1844
 
1888
 
        :param control_dir: BzrDir of the checkout to change
 
1845
        :param control_dir: ControlDir of the checkout to change
1889
1846
        :param to_branch: branch that the checkout is to reference
1890
1847
        :param force: skip the check for local commits in a heavy checkout
1891
1848
        :param revision_id: revision ID to switch to (or None)
1899
1856
        return self.__dict__ == other.__dict__
1900
1857
 
1901
1858
    def __repr__(self):
1902
 
        return "<%s for %s to (%s, %s)>" % (self.__class__.__name__,
1903
 
            self.control_dir, self.to_branch,
 
1859
        return "<%s for %s to (%s, %s)>" % (
 
1860
            self.__class__.__name__, self.control_dir, self.to_branch,
1904
1861
            self.revision_id)
1905
1862
 
1906
1863
 
1907
 
class BzrBranchFormat4(BranchFormat):
1908
 
    """Bzr branch format 4.
1909
 
 
1910
 
    This format has:
1911
 
     - a revision-history file.
1912
 
     - a branch-lock lock file [ to be shared with the bzrdir ]
1913
 
    """
1914
 
 
1915
 
    def get_format_description(self):
1916
 
        """See BranchFormat.get_format_description()."""
1917
 
        return "Branch format 4"
1918
 
 
1919
 
    def initialize(self, a_bzrdir, name=None):
1920
 
        """Create a branch of this format in a_bzrdir."""
1921
 
        utf8_files = [('revision-history', ''),
1922
 
                      ('branch-name', ''),
1923
 
                      ]
1924
 
        return self._initialize_helper(a_bzrdir, utf8_files, name=name,
1925
 
                                       lock_type='branch4', set_format=False)
1926
 
 
1927
 
    def __init__(self):
1928
 
        super(BzrBranchFormat4, self).__init__()
1929
 
        self._matchingbzrdir = bzrdir.BzrDirFormat6()
1930
 
 
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()
1934
 
 
1935
 
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
1936
 
        """See BranchFormat.open()."""
1937
 
        if not _found:
1938
 
            # we are being called directly and must probe.
1939
 
            raise NotImplementedError
1940
 
        return BzrBranch(_format=self,
1941
 
                         _control_files=a_bzrdir._control_files,
1942
 
                         a_bzrdir=a_bzrdir,
1943
 
                         name=name,
1944
 
                         _repository=a_bzrdir.open_repository())
1945
 
 
1946
 
    def __str__(self):
1947
 
        return "Bazaar-NG branch format 4"
1948
 
 
1949
 
 
1950
 
class BranchFormatMetadir(BranchFormat):
1951
 
    """Common logic for meta-dir based branch formats."""
1952
 
 
1953
 
    def _branch_class(self):
1954
 
        """What class to instantiate on open calls."""
1955
 
        raise NotImplementedError(self._branch_class)
1956
 
 
1957
 
    def network_name(self):
1958
 
        """A simple byte string uniquely identifying this format for RPC calls.
1959
 
 
1960
 
        Metadir branch formats use their format string.
1961
 
        """
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
 
        if not _found:
1967
 
            format = BranchFormat.find_format(a_bzrdir, name=name)
1968
 
            if format.__class__ != self.__class__:
1969
 
                raise AssertionError("wrong format %r found for %r" %
1970
 
                    (format, self))
1971
 
        transport = a_bzrdir.get_branch_transport(None, name=name)
1972
 
        try:
1973
 
            control_files = lockable_files.LockableFiles(transport, 'lock',
1974
 
                                                         lockdir.LockDir)
1975
 
            return self._branch_class()(_format=self,
1976
 
                              _control_files=control_files,
1977
 
                              name=name,
1978
 
                              a_bzrdir=a_bzrdir,
1979
 
                              _repository=a_bzrdir.find_repository(),
1980
 
                              ignore_fallbacks=ignore_fallbacks)
1981
 
        except errors.NoSuchFile:
1982
 
            raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1983
 
 
1984
 
    def __init__(self):
1985
 
        super(BranchFormatMetadir, self).__init__()
1986
 
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1987
 
        self._matchingbzrdir.set_branch_format(self)
1988
 
 
1989
 
    def supports_tags(self):
1990
 
        return True
1991
 
 
1992
 
 
1993
 
class BzrBranchFormat5(BranchFormatMetadir):
1994
 
    """Bzr branch format 5.
1995
 
 
1996
 
    This format has:
1997
 
     - a revision-history file.
1998
 
     - a format string
1999
 
     - a lock dir guarding the branch itself
2000
 
     - all of this stored in a branch/ subdirectory
2001
 
     - works with shared repositories.
2002
 
 
2003
 
    This format is new in bzr 0.8.
2004
 
    """
2005
 
 
2006
 
    def _branch_class(self):
2007
 
        return BzrBranch5
2008
 
 
2009
 
    def get_format_string(self):
2010
 
        """See BranchFormat.get_format_string()."""
2011
 
        return "Bazaar-NG branch format 5\n"
2012
 
 
2013
 
    def get_format_description(self):
2014
 
        """See BranchFormat.get_format_description()."""
2015
 
        return "Branch format 5"
2016
 
 
2017
 
    def initialize(self, a_bzrdir, name=None):
2018
 
        """Create a branch of this format in a_bzrdir."""
2019
 
        utf8_files = [('revision-history', ''),
2020
 
                      ('branch-name', ''),
2021
 
                      ]
2022
 
        return self._initialize_helper(a_bzrdir, utf8_files, name)
2023
 
 
2024
 
    def supports_tags(self):
2025
 
        return False
2026
 
 
2027
 
 
2028
 
class BzrBranchFormat6(BranchFormatMetadir):
2029
 
    """Branch format with last-revision and tags.
2030
 
 
2031
 
    Unlike previous formats, this has no explicit revision history. Instead,
2032
 
    this just stores the last-revision, and the left-hand history leading
2033
 
    up to there is the history.
2034
 
 
2035
 
    This format was introduced in bzr 0.15
2036
 
    and became the default in 0.91.
2037
 
    """
2038
 
 
2039
 
    def _branch_class(self):
2040
 
        return BzrBranch6
2041
 
 
2042
 
    def get_format_string(self):
2043
 
        """See BranchFormat.get_format_string()."""
2044
 
        return "Bazaar Branch Format 6 (bzr 0.15)\n"
2045
 
 
2046
 
    def get_format_description(self):
2047
 
        """See BranchFormat.get_format_description()."""
2048
 
        return "Branch format 6"
2049
 
 
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):
2108
 
    """Branch format with last-revision, tags, and a stacked location pointer.
2109
 
 
2110
 
    The stacked location pointer is passed down to the repository and requires
2111
 
    a repository format with supports_external_lookups = True.
2112
 
 
2113
 
    This format was introduced in bzr 1.6.
2114
 
    """
2115
 
 
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
 
    def _branch_class(self):
2125
 
        return BzrBranch7
2126
 
 
2127
 
    def get_format_string(self):
2128
 
        """See BranchFormat.get_format_string()."""
2129
 
        return "Bazaar Branch Format 7 (needs bzr 1.6)\n"
2130
 
 
2131
 
    def get_format_description(self):
2132
 
        """See BranchFormat.get_format_description()."""
2133
 
        return "Branch format 7"
2134
 
 
2135
 
    def supports_set_append_revisions_only(self):
2136
 
        return True
2137
 
 
2138
 
    supports_reference_locations = False
2139
 
 
2140
 
 
2141
 
class BranchReferenceFormat(BranchFormat):
2142
 
    """Bzr branch reference format.
2143
 
 
2144
 
    Branch references are used in implementing checkouts, they
2145
 
    act as an alias to the real branch which is at some other url.
2146
 
 
2147
 
    This format has:
2148
 
     - A location file
2149
 
     - a format string
2150
 
    """
2151
 
 
2152
 
    def get_format_string(self):
2153
 
        """See BranchFormat.get_format_string()."""
2154
 
        return "Bazaar-NG Branch Reference Format 1\n"
2155
 
 
2156
 
    def get_format_description(self):
2157
 
        """See BranchFormat.get_format_description()."""
2158
 
        return "Checkout reference format 1"
2159
 
 
2160
 
    def get_reference(self, a_bzrdir):
2161
 
        """See BranchFormat.get_reference()."""
2162
 
        transport = a_bzrdir.get_branch_transport(None)
2163
 
        return transport.get_bytes('location')
2164
 
 
2165
 
    def set_reference(self, a_bzrdir, to_branch):
2166
 
        """See BranchFormat.set_reference()."""
2167
 
        transport = a_bzrdir.get_branch_transport(None)
2168
 
        location = transport.put_bytes('location', to_branch.base)
2169
 
 
2170
 
    def initialize(self, a_bzrdir, name=None, target_branch=None):
2171
 
        """Create a branch of this format in a_bzrdir."""
2172
 
        if target_branch is None:
2173
 
            # this format does not implement branch itself, thus the implicit
2174
 
            # creation contract must see it as uninitializable
2175
 
            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)
2178
 
        branch_transport.put_bytes('location',
2179
 
            target_branch.bzrdir.user_url)
2180
 
        branch_transport.put_bytes('format', self.get_format_string())
2181
 
        branch = self.open(
2182
 
            a_bzrdir, name, _found=True,
2183
 
            possible_transports=[target_branch.bzrdir.root_transport])
2184
 
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2185
 
        return branch
2186
 
 
2187
 
    def __init__(self):
2188
 
        super(BranchReferenceFormat, self).__init__()
2189
 
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
2190
 
        self._matchingbzrdir.set_branch_format(self)
2191
 
 
2192
 
    def _make_reference_clone_function(format, a_branch):
2193
 
        """Create a clone() routine for a branch dynamically."""
2194
 
        def clone(to_bzrdir, revision_id=None,
2195
 
            repository_policy=None):
2196
 
            """See Branch.clone()."""
2197
 
            return format.initialize(to_bzrdir, target_branch=a_branch)
2198
 
            # cannot obey revision_id limits when cloning a reference ...
2199
 
            # FIXME RBC 20060210 either nuke revision_id for clone, or
2200
 
            # emit some sort of warning/error to the caller ?!
2201
 
        return clone
2202
 
 
2203
 
    def open(self, a_bzrdir, name=None, _found=False, location=None,
2204
 
             possible_transports=None, ignore_fallbacks=False):
2205
 
        """Return the branch that the branch reference in a_bzrdir points at.
2206
 
 
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.
2217
 
        """
2218
 
        if not _found:
2219
 
            format = BranchFormat.find_format(a_bzrdir, name=name)
2220
 
            if format.__class__ != self.__class__:
2221
 
                raise AssertionError("wrong format %r found for %r" %
2222
 
                    (format, self))
2223
 
        if location is None:
2224
 
            location = self.get_reference(a_bzrdir)
2225
 
        real_bzrdir = bzrdir.BzrDir.open(
2226
 
            location, possible_transports=possible_transports)
2227
 
        result = real_bzrdir.open_branch(name=name, 
2228
 
            ignore_fallbacks=ignore_fallbacks)
2229
 
        # this changes the behaviour of result.clone to create a new reference
2230
 
        # rather than a copy of the content of the branch.
2231
 
        # I did not use a proxy object because that needs much more extensive
2232
 
        # testing, and we are only changing one behaviour at the moment.
2233
 
        # If we decide to alter more behaviours - i.e. the implicit nickname
2234
 
        # then this should be refactored to introduce a tested proxy branch
2235
 
        # and a subclass of that for use in overriding clone() and ....
2236
 
        # - RBC 20060210
2237
 
        result.clone = self._make_reference_clone_function(result)
2238
 
        return result
 
1864
class BranchFormatRegistry(controldir.ControlComponentFormatRegistry):
 
1865
    """Branch format registry."""
 
1866
 
 
1867
    def __init__(self, other_registry=None):
 
1868
        super(BranchFormatRegistry, self).__init__(other_registry)
 
1869
        self._default_format = None
 
1870
        self._default_format_key = None
 
1871
 
 
1872
    def get_default(self):
 
1873
        """Return the current default format."""
 
1874
        if (self._default_format_key is not None
 
1875
                and self._default_format is None):
 
1876
            self._default_format = self.get(self._default_format_key)
 
1877
        return self._default_format
 
1878
 
 
1879
    def set_default(self, format):
 
1880
        """Set the default format."""
 
1881
        self._default_format = format
 
1882
        self._default_format_key = None
 
1883
 
 
1884
    def set_default_key(self, format_string):
 
1885
        """Set the default format by its format string."""
 
1886
        self._default_format_key = format_string
 
1887
        self._default_format = None
2239
1888
 
2240
1889
 
2241
1890
network_format_registry = registry.FormatRegistry()
2246
1895
BranchFormat.network_name() for more detail.
2247
1896
"""
2248
1897
 
 
1898
format_registry = BranchFormatRegistry(network_format_registry)
 
1899
 
2249
1900
 
2250
1901
# formats which have no format string are not discoverable
2251
1902
# and not independently creatable, so are not registered.
2252
 
__format5 = BzrBranchFormat5()
2253
 
__format6 = BzrBranchFormat6()
2254
 
__format7 = BzrBranchFormat7()
2255
 
__format8 = BzrBranchFormat8()
2256
 
BranchFormat.register_format(__format5)
2257
 
BranchFormat.register_format(BranchReferenceFormat())
2258
 
BranchFormat.register_format(__format6)
2259
 
BranchFormat.register_format(__format7)
2260
 
BranchFormat.register_format(__format8)
2261
 
BranchFormat.set_default_format(__format7)
2262
 
_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):
2269
 
    """A branch stored in the actual filesystem.
2270
 
 
2271
 
    Note that it's "local" in the context of the filesystem; it doesn't
2272
 
    really matter if it's on an nfs/smb/afs/coda/... share, as long as
2273
 
    it's writable, and can be accessed via the normal filesystem API.
2274
 
 
2275
 
    :ivar _transport: Transport for file operations on this branch's
2276
 
        control files, typically pointing to the .bzr/branch directory.
2277
 
    :ivar repository: Repository for this branch.
2278
 
    :ivar base: The url of the base directory for this branch; the one
2279
 
        containing the .bzr directory.
2280
 
    :ivar name: Optional colocated branch name as it exists in the control
2281
 
        directory.
2282
 
    """
2283
 
 
2284
 
    def __init__(self, _format=None,
2285
 
                 _control_files=None, a_bzrdir=None, name=None,
2286
 
                 _repository=None, ignore_fallbacks=False):
2287
 
        """Create new branch object at a particular location."""
2288
 
        if a_bzrdir is None:
2289
 
            raise ValueError('a_bzrdir must be supplied')
2290
 
        else:
2291
 
            self.bzrdir = a_bzrdir
2292
 
        self._base = self.bzrdir.transport.clone('..').base
2293
 
        self.name = name
2294
 
        # XXX: We should be able to just do
2295
 
        #   self.base = self.bzrdir.root_transport.base
2296
 
        # but this does not quite work yet -- mbp 20080522
2297
 
        self._format = _format
2298
 
        if _control_files is None:
2299
 
            raise ValueError('BzrBranch _control_files is None')
2300
 
        self.control_files = _control_files
2301
 
        self._transport = _control_files._transport
2302
 
        self.repository = _repository
2303
 
        Branch.__init__(self)
2304
 
 
2305
 
    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)
2311
 
 
2312
 
    __repr__ = __str__
2313
 
 
2314
 
    def _get_base(self):
2315
 
        """Returns the directory containing the control directory."""
2316
 
        return self._base
2317
 
 
2318
 
    base = property(_get_base, doc="The URL for the root of this branch.")
2319
 
 
2320
 
    def _get_config(self):
2321
 
        return TransportConfig(self._transport, 'branch.conf')
2322
 
 
2323
 
    def is_locked(self):
2324
 
        return self.control_files.is_locked()
2325
 
 
2326
 
    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
2337
 
        try:
2338
 
            return self.control_files.lock_write(token=token)
2339
 
        except:
2340
 
            if took_lock:
2341
 
                self.repository.unlock()
2342
 
            raise
2343
 
 
2344
 
    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
2355
 
        try:
2356
 
            self.control_files.lock_read()
2357
 
        except:
2358
 
            if took_lock:
2359
 
                self.repository.unlock()
2360
 
            raise
2361
 
 
2362
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
2363
 
    def unlock(self):
2364
 
        try:
2365
 
            self.control_files.unlock()
2366
 
        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
 
 
2376
 
    def peek_lock_mode(self):
2377
 
        if self.control_files._lock_count == 0:
2378
 
            return None
2379
 
        else:
2380
 
            return self.control_files._lock_mode
2381
 
 
2382
 
    def get_physical_lock_status(self):
2383
 
        return self.control_files.get_physical_lock_status()
2384
 
 
2385
 
    @needs_read_lock
2386
 
    def print_file(self, file, revision_id):
2387
 
        """See Branch.print_file."""
2388
 
        return self.repository.print_file(file, revision_id)
2389
 
 
2390
 
    def _write_revision_history(self, history):
2391
 
        """Factored out of set_revision_history.
2392
 
 
2393
 
        This performs the actual writing to disk.
2394
 
        It is intended to be called by BzrBranch5.set_revision_history."""
2395
 
        self._transport.put_bytes(
2396
 
            'revision-history', '\n'.join(history),
2397
 
            mode=self.bzrdir._get_file_mode())
2398
 
 
2399
 
    @needs_write_lock
2400
 
    def set_revision_history(self, rev_history):
2401
 
        """See Branch.set_revision_history."""
2402
 
        if 'evil' in debug.debug_flags:
2403
 
            mutter_callsite(3, "set_revision_history scales with history.")
2404
 
        check_not_reserved_id = _mod_revision.check_not_reserved_id
2405
 
        for rev_id in rev_history:
2406
 
            check_not_reserved_id(rev_id)
2407
 
        if Branch.hooks['post_change_branch_tip']:
2408
 
            # Don't calculate the last_revision_info() if there are no hooks
2409
 
            # that will use it.
2410
 
            old_revno, old_revid = self.last_revision_info()
2411
 
        if len(rev_history) == 0:
2412
 
            revid = _mod_revision.NULL_REVISION
2413
 
        else:
2414
 
            revid = rev_history[-1]
2415
 
        self._run_pre_change_branch_tip_hooks(len(rev_history), revid)
2416
 
        self._write_revision_history(rev_history)
2417
 
        self._clear_cached_state()
2418
 
        self._cache_revision_history(rev_history)
2419
 
        for hook in Branch.hooks['set_rh']:
2420
 
            hook(self, rev_history)
2421
 
        if Branch.hooks['post_change_branch_tip']:
2422
 
            self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2423
 
 
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)
2440
 
            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 != []:
2446
 
            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
 
 
2453
 
    @needs_write_lock
2454
 
    def set_last_revision_info(self, revno, revision_id):
2455
 
        """Set the last revision of this branch.
2456
 
 
2457
 
        The caller is responsible for checking that the revno is correct
2458
 
        for this revision id.
2459
 
 
2460
 
        It may be possible to set the branch last revision to an id not
2461
 
        present in the repository.  However, branches can also be
2462
 
        configured to check constraints on history, in which case this may not
2463
 
        be permitted.
2464
 
        """
2465
 
        revision_id = _mod_revision.ensure_null(revision_id)
2466
 
        # this old format stores the full history, but this api doesn't
2467
 
        # provide it, so we must generate, and might as well check it's
2468
 
        # correct
2469
 
        history = self._lefthand_history(revision_id)
2470
 
        if len(history) != revno:
2471
 
            raise AssertionError('%d != %d' % (len(history), revno))
2472
 
        self.set_revision_history(history)
2473
 
 
2474
 
    def _gen_revision_history(self):
2475
 
        history = self._transport.get_bytes('revision-history').split('\n')
2476
 
        if history[-1:] == ['']:
2477
 
            # There shouldn't be a trailing newline, but just in case.
2478
 
            history.pop()
2479
 
        return history
2480
 
 
2481
 
    @needs_write_lock
2482
 
    def generate_revision_history(self, revision_id, last_rev=None,
2483
 
        other_branch=None):
2484
 
        """Create a new revision history that will finish with revision_id.
2485
 
 
2486
 
        :param revision_id: the new tip to use.
2487
 
        :param last_rev: The previous last_revision. If not None, then this
2488
 
            must be a ancestory of revision_id, or DivergedBranches is raised.
2489
 
        :param other_branch: The other branch that DivergedBranches should
2490
 
            raise with respect to.
2491
 
        """
2492
 
        self.set_revision_history(self._lefthand_history(revision_id,
2493
 
            last_rev, other_branch))
2494
 
 
2495
 
    def basis_tree(self):
2496
 
        """See Branch.basis_tree."""
2497
 
        return self.repository.revision_tree(self.last_revision())
2498
 
 
2499
 
    def _get_parent_location(self):
2500
 
        _locs = ['parent', 'pull', 'x-pull']
2501
 
        for l in _locs:
2502
 
            try:
2503
 
                return self._transport.get_bytes(l).strip('\n')
2504
 
            except errors.NoSuchFile:
2505
 
                pass
2506
 
        return None
2507
 
 
2508
 
    def _basic_push(self, target, overwrite, stop_revision):
2509
 
        """Basic implementation of push without bound branches or hooks.
2510
 
 
2511
 
        Must be called with source read locked and target write locked.
2512
 
        """
2513
 
        result = BranchPushResult()
2514
 
        result.source_branch = self
2515
 
        result.target_branch = target
2516
 
        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)
2527
 
        result.new_revno, result.new_revid = target.last_revision_info()
2528
 
        return result
2529
 
 
2530
 
    def get_stacked_on_url(self):
2531
 
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
2532
 
 
2533
 
    def set_push_location(self, location):
2534
 
        """See Branch.set_push_location."""
2535
 
        self.get_config().set_user_option(
2536
 
            'push_location', location,
2537
 
            store=_mod_config.STORE_LOCATION_NORECURSE)
2538
 
 
2539
 
    def _set_parent_location(self, url):
2540
 
        if url is None:
2541
 
            self._transport.delete('parent')
2542
 
        else:
2543
 
            self._transport.put_bytes('parent', url + '\n',
2544
 
                mode=self.bzrdir._get_file_mode())
2545
 
 
2546
 
 
2547
 
class BzrBranch5(BzrBranch):
2548
 
    """A format 5 branch. This supports new features over plain branches.
2549
 
 
2550
 
    It has support for a master_branch which is the data for bound branches.
2551
 
    """
2552
 
 
2553
 
    def get_bound_location(self):
2554
 
        try:
2555
 
            return self._transport.get_bytes('bound')[:-1]
2556
 
        except errors.NoSuchFile:
2557
 
            return None
2558
 
 
2559
 
    @needs_read_lock
2560
 
    def get_master_branch(self, possible_transports=None):
2561
 
        """Return the branch we are bound to.
2562
 
 
2563
 
        :return: Either a Branch, or None
2564
 
 
2565
 
        This could memoise the branch, but if thats done
2566
 
        it must be revalidated on each new lock.
2567
 
        So for now we just don't memoise it.
2568
 
        # RBC 20060304 review this decision.
2569
 
        """
2570
 
        bound_loc = self.get_bound_location()
2571
 
        if not bound_loc:
2572
 
            return None
2573
 
        try:
2574
 
            return Branch.open(bound_loc,
2575
 
                               possible_transports=possible_transports)
2576
 
        except (errors.NotBranchError, errors.ConnectionError), e:
2577
 
            raise errors.BoundBranchConnectionFailure(
2578
 
                    self, bound_loc, e)
2579
 
 
2580
 
    @needs_write_lock
2581
 
    def set_bound_location(self, location):
2582
 
        """Set the target where this branch is bound to.
2583
 
 
2584
 
        :param location: URL to the target branch
2585
 
        """
2586
 
        if location:
2587
 
            self._transport.put_bytes('bound', location+'\n',
2588
 
                mode=self.bzrdir._get_file_mode())
2589
 
        else:
2590
 
            try:
2591
 
                self._transport.delete('bound')
2592
 
            except errors.NoSuchFile:
2593
 
                return False
2594
 
            return True
2595
 
 
2596
 
    @needs_write_lock
2597
 
    def bind(self, other):
2598
 
        """Bind this branch to the branch other.
2599
 
 
2600
 
        This does not push or pull data between the branches, though it does
2601
 
        check for divergence to raise an error when the branches are not
2602
 
        either the same, or one a prefix of the other. That behaviour may not
2603
 
        be useful, so that check may be removed in future.
2604
 
 
2605
 
        :param other: The branch to bind to
2606
 
        :type other: Branch
2607
 
        """
2608
 
        # TODO: jam 20051230 Consider checking if the target is bound
2609
 
        #       It is debatable whether you should be able to bind to
2610
 
        #       a branch which is itself bound.
2611
 
        #       Committing is obviously forbidden,
2612
 
        #       but binding itself may not be.
2613
 
        #       Since we *have* to check at commit time, we don't
2614
 
        #       *need* to check here
2615
 
 
2616
 
        # we want to raise diverged if:
2617
 
        # last_rev is not in the other_last_rev history, AND
2618
 
        # other_last_rev is not in our history, and do it without pulling
2619
 
        # history around
2620
 
        self.set_bound_location(other.base)
2621
 
 
2622
 
    @needs_write_lock
2623
 
    def unbind(self):
2624
 
        """If bound, unbind"""
2625
 
        return self.set_bound_location(None)
2626
 
 
2627
 
    @needs_write_lock
2628
 
    def update(self, possible_transports=None):
2629
 
        """Synchronise this branch with the master branch if any.
2630
 
 
2631
 
        :return: None or the last_revision that was pivoted out during the
2632
 
                 update.
2633
 
        """
2634
 
        master = self.get_master_branch(possible_transports)
2635
 
        if master is not None:
2636
 
            old_tip = _mod_revision.ensure_null(self.last_revision())
2637
 
            self.pull(master, overwrite=True)
2638
 
            if self.repository.get_graph().is_ancestor(old_tip,
2639
 
                _mod_revision.ensure_null(self.last_revision())):
2640
 
                return None
2641
 
            return old_tip
2642
 
        return None
2643
 
 
2644
 
 
2645
 
class BzrBranch8(BzrBranch5):
2646
 
    """A branch that stores tree-reference locations."""
2647
 
 
2648
 
    def _open_hook(self):
2649
 
        if self._ignore_fallbacks:
2650
 
            return
2651
 
        try:
2652
 
            url = self.get_stacked_on_url()
2653
 
        except (errors.UnstackableRepositoryFormat, errors.NotStacked,
2654
 
            errors.UnstackableBranchFormat):
2655
 
            pass
2656
 
        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
 
            self._activate_fallback_location(url)
2665
 
 
2666
 
    def __init__(self, *args, **kwargs):
2667
 
        self._ignore_fallbacks = kwargs.get('ignore_fallbacks', False)
2668
 
        super(BzrBranch8, self).__init__(*args, **kwargs)
2669
 
        self._last_revision_info_cache = None
2670
 
        self._reference_info = None
2671
 
 
2672
 
    def _clear_cached_state(self):
2673
 
        super(BzrBranch8, self)._clear_cached_state()
2674
 
        self._last_revision_info_cache = None
2675
 
        self._reference_info = None
2676
 
 
2677
 
    def _last_revision_info(self):
2678
 
        revision_string = self._transport.get_bytes('last-revision')
2679
 
        revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
2680
 
        revision_id = cache_utf8.get_cached_utf8(revision_id)
2681
 
        revno = int(revno)
2682
 
        return revno, revision_id
2683
 
 
2684
 
    def _write_last_revision_info(self, revno, revision_id):
2685
 
        """Simply write out the revision id, with no checks.
2686
 
 
2687
 
        Use set_last_revision_info to perform this safely.
2688
 
 
2689
 
        Does not update the revision_history cache.
2690
 
        Intended to be called by set_last_revision_info and
2691
 
        _write_revision_history.
2692
 
        """
2693
 
        revision_id = _mod_revision.ensure_null(revision_id)
2694
 
        out_string = '%d %s\n' % (revno, revision_id)
2695
 
        self._transport.put_bytes('last-revision', out_string,
2696
 
            mode=self.bzrdir._get_file_mode())
2697
 
 
2698
 
    @needs_write_lock
2699
 
    def set_last_revision_info(self, revno, revision_id):
2700
 
        revision_id = _mod_revision.ensure_null(revision_id)
2701
 
        old_revno, old_revid = self.last_revision_info()
2702
 
        if self._get_append_revisions_only():
2703
 
            self._check_history_violation(revision_id)
2704
 
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2705
 
        self._write_last_revision_info(revno, revision_id)
2706
 
        self._clear_cached_state()
2707
 
        self._last_revision_info_cache = revno, revision_id
2708
 
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2709
 
 
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
 
    def _check_history_violation(self, revision_id):
2723
 
        last_revision = _mod_revision.ensure_null(self.last_revision())
2724
 
        if _mod_revision.is_null(last_revision):
2725
 
            return
2726
 
        if last_revision not in self._lefthand_history(revision_id):
2727
 
            raise errors.AppendRevisionsOnlyViolation(self.user_url)
2728
 
 
2729
 
    def _gen_revision_history(self):
2730
 
        """Generate the revision history from last revision
2731
 
        """
2732
 
        last_revno, last_revision = self.last_revision_info()
2733
 
        self._extend_partial_history(stop_index=last_revno-1)
2734
 
        return list(reversed(self._partial_revision_history_cache))
2735
 
 
2736
 
    def _write_revision_history(self, history):
2737
 
        """Factored out of set_revision_history.
2738
 
 
2739
 
        This performs the actual writing to disk, with format-specific checks.
2740
 
        It is intended to be called by BzrBranch5.set_revision_history.
2741
 
        """
2742
 
        if len(history) == 0:
2743
 
            last_revision = 'null:'
2744
 
        else:
2745
 
            if history != self._lefthand_history(history[-1]):
2746
 
                raise errors.NotLefthandHistory(history)
2747
 
            last_revision = history[-1]
2748
 
        if self._get_append_revisions_only():
2749
 
            self._check_history_violation(last_revision)
2750
 
        self._write_last_revision_info(len(history), last_revision)
2751
 
 
2752
 
    @needs_write_lock
2753
 
    def _set_parent_location(self, url):
2754
 
        """Set the parent branch"""
2755
 
        self._set_config_location('parent_location', url, make_relative=True)
2756
 
 
2757
 
    @needs_read_lock
2758
 
    def _get_parent_location(self):
2759
 
        """Set the parent branch"""
2760
 
        return self._get_config_location('parent_location')
2761
 
 
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
 
    def set_push_location(self, location):
2838
 
        """See Branch.set_push_location."""
2839
 
        self._set_config_location('push_location', location)
2840
 
 
2841
 
    def set_bound_location(self, location):
2842
 
        """See Branch.set_push_location."""
2843
 
        result = None
2844
 
        config = self.get_config()
2845
 
        if location is None:
2846
 
            if config.get_user_option('bound') != 'True':
2847
 
                return False
2848
 
            else:
2849
 
                config.set_user_option('bound', 'False', warn_masked=True)
2850
 
                return True
2851
 
        else:
2852
 
            self._set_config_location('bound_location', location,
2853
 
                                      config=config)
2854
 
            config.set_user_option('bound', 'True', warn_masked=True)
2855
 
        return True
2856
 
 
2857
 
    def _get_bound_location(self, bound):
2858
 
        """Return the bound location in the config file.
2859
 
 
2860
 
        Return None if the bound parameter does not match"""
2861
 
        config = self.get_config()
2862
 
        config_bound = (config.get_user_option('bound') == 'True')
2863
 
        if config_bound != bound:
2864
 
            return None
2865
 
        return self._get_config_location('bound_location', config=config)
2866
 
 
2867
 
    def get_bound_location(self):
2868
 
        """See Branch.set_push_location."""
2869
 
        return self._get_bound_location(True)
2870
 
 
2871
 
    def get_old_bound_location(self):
2872
 
        """See Branch.get_old_bound_location"""
2873
 
        return self._get_bound_location(False)
2874
 
 
2875
 
    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()
2879
 
        stacked_url = self._get_config_location('stacked_on_location')
2880
 
        if stacked_url is None:
2881
 
            raise errors.NotStacked(self)
2882
 
        return stacked_url
2883
 
 
2884
 
    def _get_append_revisions_only(self):
2885
 
        return self.get_config(
2886
 
            ).get_user_option_as_bool('append_revisions_only')
2887
 
 
2888
 
    @needs_write_lock
2889
 
    def generate_revision_history(self, revision_id, last_rev=None,
2890
 
                                  other_branch=None):
2891
 
        """See BzrBranch5.generate_revision_history"""
2892
 
        history = self._lefthand_history(revision_id, last_rev, other_branch)
2893
 
        revno = len(history)
2894
 
        self.set_last_revision_info(revno, revision_id)
2895
 
 
2896
 
    @needs_read_lock
2897
 
    def get_rev_id(self, revno, history=None):
2898
 
        """Find the revision id of the specified revno."""
2899
 
        if revno == 0:
2900
 
            return _mod_revision.NULL_REVISION
2901
 
 
2902
 
        last_revno, last_revision_id = self.last_revision_info()
2903
 
        if revno <= 0 or revno > last_revno:
2904
 
            raise errors.NoSuchRevision(self, revno)
2905
 
 
2906
 
        if history is not None:
2907
 
            return history[revno - 1]
2908
 
 
2909
 
        index = last_revno - revno
2910
 
        if len(self._partial_revision_history_cache) <= index:
2911
 
            self._extend_partial_history(stop_index=index)
2912
 
        if len(self._partial_revision_history_cache) > index:
2913
 
            return self._partial_revision_history_cache[index]
2914
 
        else:
2915
 
            raise errors.NoSuchRevision(self, revno)
2916
 
 
2917
 
    @needs_read_lock
2918
 
    def revision_id_to_revno(self, revision_id):
2919
 
        """Given a revision id, return its revno"""
2920
 
        if _mod_revision.is_null(revision_id):
2921
 
            return 0
2922
 
        try:
2923
 
            index = self._partial_revision_history_cache.index(revision_id)
2924
 
        except ValueError:
2925
 
            self._extend_partial_history(stop_revision=revision_id)
2926
 
            index = len(self._partial_revision_history_cache) - 1
2927
 
            if self._partial_revision_history_cache[index] != revision_id:
2928
 
                raise errors.NoSuchRevision(self, revision_id)
2929
 
        return self.revno() - index
2930
 
 
2931
 
 
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
 
class BzrBranch6(BzrBranch7):
2947
 
    """See BzrBranchFormat6 for the capabilities of this branch.
2948
 
 
2949
 
    This subclass of BzrBranch7 disables the new features BzrBranch7 added,
2950
 
    i.e. stacking.
2951
 
    """
2952
 
 
2953
 
    def get_stacked_on_url(self):
2954
 
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
 
1903
format_registry.register_lazy(
 
1904
    b"Bazaar-NG branch format 5\n", "breezy.bzr.fullhistory",
 
1905
    "BzrBranchFormat5")
 
1906
format_registry.register_lazy(
 
1907
    b"Bazaar Branch Format 6 (bzr 0.15)\n",
 
1908
    "breezy.bzr.branch", "BzrBranchFormat6")
 
1909
format_registry.register_lazy(
 
1910
    b"Bazaar Branch Format 7 (needs bzr 1.6)\n",
 
1911
    "breezy.bzr.branch", "BzrBranchFormat7")
 
1912
format_registry.register_lazy(
 
1913
    b"Bazaar Branch Format 8 (needs bzr 1.15)\n",
 
1914
    "breezy.bzr.branch", "BzrBranchFormat8")
 
1915
format_registry.register_lazy(
 
1916
    b"Bazaar-NG Branch Reference Format 1\n",
 
1917
    "breezy.bzr.branch", "BranchReferenceFormat")
 
1918
 
 
1919
format_registry.set_default_key(b"Bazaar Branch Format 7 (needs bzr 1.6)\n")
 
1920
 
 
1921
 
 
1922
class BranchWriteLockResult(LogicalLockResult):
 
1923
    """The result of write locking a branch.
 
1924
 
 
1925
    :ivar token: The token obtained from the underlying branch lock, or
 
1926
        None.
 
1927
    :ivar unlock: A callable which will unlock the lock.
 
1928
    """
 
1929
 
 
1930
    def __repr__(self):
 
1931
        return "BranchWriteLockResult(%r, %r)" % (self.unlock, self.token)
2955
1932
 
2956
1933
 
2957
1934
######################################################################
2981
1958
    :ivar local_branch: target branch if there is a Master, else None
2982
1959
    :ivar target_branch: Target/destination branch object. (write locked)
2983
1960
    :ivar tag_conflicts: A list of tag conflicts, see BasicTags.merge_to
 
1961
    :ivar tag_updates: A dict with new tags, see BasicTags.merge_to
2984
1962
    """
2985
1963
 
2986
 
    def __int__(self):
2987
 
        # DEPRECATED: pull used to return the change in revno
2988
 
        return self.new_revno - self.old_revno
2989
 
 
2990
1964
    def report(self, to_file):
 
1965
        tag_conflicts = getattr(self, "tag_conflicts", None)
 
1966
        tag_updates = getattr(self, "tag_updates", None)
2991
1967
        if not is_quiet():
2992
 
            if self.old_revid == self.new_revid:
2993
 
                to_file.write('No revisions to pull.\n')
2994
 
            else:
 
1968
            if self.old_revid != self.new_revid:
2995
1969
                to_file.write('Now on revision %d.\n' % self.new_revno)
 
1970
            if tag_updates:
 
1971
                to_file.write('%d tag(s) updated.\n' % len(tag_updates))
 
1972
            if self.old_revid == self.new_revid and not tag_updates:
 
1973
                if not tag_conflicts:
 
1974
                    to_file.write('No revisions or tags to pull.\n')
 
1975
                else:
 
1976
                    to_file.write('No revisions to pull.\n')
2996
1977
        self._show_tag_conficts(to_file)
2997
1978
 
2998
1979
 
3015
1996
        target, otherwise it will be None.
3016
1997
    """
3017
1998
 
3018
 
    def __int__(self):
3019
 
        # DEPRECATED: push used to return the change in revno
3020
 
        return self.new_revno - self.old_revno
3021
 
 
3022
1999
    def report(self, to_file):
3023
 
        """Write a human-readable description of the result."""
3024
 
        if self.old_revid == self.new_revid:
3025
 
            note('No new revisions to push.')
3026
 
        else:
3027
 
            note('Pushed up to revision %d.' % self.new_revno)
 
2000
        # TODO: This function gets passed a to_file, but then
 
2001
        # ignores it and calls note() instead. This is also
 
2002
        # inconsistent with PullResult(), which writes to stdout.
 
2003
        # -- JRV20110901, bug #838853
 
2004
        tag_conflicts = getattr(self, "tag_conflicts", None)
 
2005
        tag_updates = getattr(self, "tag_updates", None)
 
2006
        if not is_quiet():
 
2007
            if self.old_revid != self.new_revid:
 
2008
                if self.new_revno is not None:
 
2009
                    note(gettext('Pushed up to revision %d.'),
 
2010
                         self.new_revno)
 
2011
                else:
 
2012
                    note(gettext('Pushed up to revision id %s.'),
 
2013
                         self.new_revid.decode('utf-8'))
 
2014
            if tag_updates:
 
2015
                note(ngettext('%d tag updated.', '%d tags updated.',
 
2016
                              len(tag_updates)) % len(tag_updates))
 
2017
            if self.old_revid == self.new_revid and not tag_updates:
 
2018
                if not tag_conflicts:
 
2019
                    note(gettext('No new revisions or tags to push.'))
 
2020
                else:
 
2021
                    note(gettext('No new revisions to push.'))
3028
2022
        self._show_tag_conficts(to_file)
3029
2023
 
3030
2024
 
3044
2038
        :param verbose: Requests more detailed display of what was checked,
3045
2039
            if any.
3046
2040
        """
3047
 
        note('checked branch %s format %s', self.branch.user_url,
3048
 
            self.branch._format)
 
2041
        note(gettext('checked branch {0} format {1}').format(
 
2042
            self.branch.user_url, self.branch._format))
3049
2043
        for error in self.errors:
3050
 
            note('found error:%s', error)
3051
 
 
3052
 
 
3053
 
class Converter5to6(object):
3054
 
    """Perform an in-place upgrade of format 5 to format 6"""
3055
 
 
3056
 
    def convert(self, branch):
3057
 
        # Data for 5 and 6 can peacefully coexist.
3058
 
        format = BzrBranchFormat6()
3059
 
        new_branch = format.open(branch.bzrdir, _found=True)
3060
 
 
3061
 
        # Copy source data into target
3062
 
        new_branch._write_last_revision_info(*branch.last_revision_info())
3063
 
        new_branch.set_parent(branch.get_parent())
3064
 
        new_branch.set_bound_location(branch.get_bound_location())
3065
 
        new_branch.set_push_location(branch.get_push_location())
3066
 
 
3067
 
        # New branch has no tags by default
3068
 
        new_branch.tags._set_tag_dict({})
3069
 
 
3070
 
        # Copying done; now update target format
3071
 
        new_branch._transport.put_bytes('format',
3072
 
            format.get_format_string(),
3073
 
            mode=new_branch.bzrdir._get_file_mode())
3074
 
 
3075
 
        # Clean up old files
3076
 
        new_branch._transport.delete('revision-history')
3077
 
        try:
3078
 
            branch.set_parent(None)
3079
 
        except errors.NoSuchFile:
3080
 
            pass
3081
 
        branch.set_bound_location(None)
3082
 
 
3083
 
 
3084
 
class Converter6to7(object):
3085
 
    """Perform an in-place upgrade of format 6 to format 7"""
3086
 
 
3087
 
    def convert(self, branch):
3088
 
        format = BzrBranchFormat7()
3089
 
        branch._set_config_location('stacked_on_location', '')
3090
 
        # update target format
3091
 
        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
 
2044
            note(gettext('found error:%s'), error)
3135
2045
 
3136
2046
 
3137
2047
class InterBranch(InterObject):
3145
2055
    _optimisers = []
3146
2056
    """The available optimised InterBranch types."""
3147
2057
 
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)
 
2058
    @classmethod
 
2059
    def _get_branch_formats_to_test(klass):
 
2060
        """Return an iterable of format tuples for testing.
 
2061
 
 
2062
        :return: An iterable of (from_format, to_format) to use when testing
 
2063
            this InterBranch class. Each InterBranch class should define this
 
2064
            method itself.
 
2065
        """
 
2066
        raise NotImplementedError(klass._get_branch_formats_to_test)
3152
2067
 
3153
2068
    def pull(self, overwrite=False, stop_revision=None,
3154
 
             possible_transports=None, local=False):
 
2069
             possible_transports=None, local=False, tag_selector=None):
3155
2070
        """Mirror source into target branch.
3156
2071
 
3157
2072
        The target branch is considered to be 'local', having low latency.
3160
2075
        """
3161
2076
        raise NotImplementedError(self.pull)
3162
2077
 
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):
 
2078
    def push(self, overwrite=False, stop_revision=None, lossy=False,
 
2079
             _override_hook_source_branch=None, tag_selector=None):
3178
2080
        """Mirror the source branch into the target branch.
3179
2081
 
3180
2082
        The source branch is considered to be 'local', having low latency.
3181
2083
        """
3182
2084
        raise NotImplementedError(self.push)
3183
2085
 
 
2086
    def copy_content_into(self, revision_id=None, tag_selector=None):
 
2087
        """Copy the content of source into target
 
2088
 
 
2089
        :param revision_id:
 
2090
            if not None, the revision history in the new branch will
 
2091
            be truncated to end with revision_id.
 
2092
        :param tag_selector: Optional callback that can decide
 
2093
            to copy or not copy tags.
 
2094
        """
 
2095
        raise NotImplementedError(self.copy_content_into)
 
2096
 
 
2097
    def fetch(self, stop_revision=None, limit=None, lossy=False):
 
2098
        """Fetch revisions.
 
2099
 
 
2100
        :param stop_revision: Last revision to fetch
 
2101
        :param limit: Optional rough limit of revisions to fetch
 
2102
        :return: FetchResult object
 
2103
        """
 
2104
        raise NotImplementedError(self.fetch)
 
2105
 
 
2106
    def update_references(self):
 
2107
        """Import reference information from source to target.
 
2108
        """
 
2109
        raise NotImplementedError(self.update_references)
 
2110
 
 
2111
 
 
2112
def _fix_overwrite_type(overwrite):
 
2113
    if isinstance(overwrite, bool):
 
2114
        if overwrite:
 
2115
            return ["history", "tags"]
 
2116
        else:
 
2117
            return []
 
2118
    return overwrite
 
2119
 
3184
2120
 
3185
2121
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:
 
2122
    """InterBranch implementation that uses public Branch functions."""
 
2123
 
 
2124
    @classmethod
 
2125
    def is_compatible(klass, source, target):
 
2126
        # GenericBranch uses the public API, so always compatible
 
2127
        return True
 
2128
 
 
2129
    @classmethod
 
2130
    def _get_branch_formats_to_test(klass):
 
2131
        return [(format_registry.get_default(), format_registry.get_default())]
 
2132
 
 
2133
    @classmethod
 
2134
    def unwrap_format(klass, format):
 
2135
        if isinstance(format, remote.RemoteBranchFormat):
 
2136
            format._ensure_real()
 
2137
            return format._custom_format
 
2138
        return format
 
2139
 
 
2140
    def copy_content_into(self, revision_id=None, tag_selector=None):
 
2141
        """Copy the content of source into target
 
2142
 
 
2143
        revision_id: if not None, the revision history in the new branch will
 
2144
                     be truncated to end with revision_id.
 
2145
        """
 
2146
        with self.source.lock_read(), self.target.lock_write():
 
2147
            self.source._synchronize_history(self.target, revision_id)
 
2148
            self.update_references()
 
2149
            try:
 
2150
                parent = self.source.get_parent()
 
2151
            except errors.InaccessibleParent as e:
 
2152
                mutter('parent was not accessible to copy: %s', str(e))
 
2153
            else:
 
2154
                if parent:
 
2155
                    self.target.set_parent(parent)
 
2156
            if self.source._push_should_merge_tags():
 
2157
                self.source.tags.merge_to(self.target.tags, selector=tag_selector)
 
2158
 
 
2159
    def fetch(self, stop_revision=None, limit=None, lossy=False):
 
2160
        if self.target.base == self.source.base:
 
2161
            return (0, [])
 
2162
        with self.source.lock_read(), self.target.lock_write():
 
2163
            fetch_spec_factory = fetch.FetchSpecFactory()
 
2164
            fetch_spec_factory.source_branch = self.source
 
2165
            fetch_spec_factory.source_branch_stop_revision_id = stop_revision
 
2166
            fetch_spec_factory.source_repo = self.source.repository
 
2167
            fetch_spec_factory.target_repo = self.target.repository
 
2168
            fetch_spec_factory.target_repo_kind = (
 
2169
                fetch.TargetRepoKinds.PREEXISTING)
 
2170
            fetch_spec_factory.limit = limit
 
2171
            fetch_spec = fetch_spec_factory.make_fetch_spec()
 
2172
            return self.target.repository.fetch(
 
2173
                self.source.repository,
 
2174
                lossy=lossy,
 
2175
                fetch_spec=fetch_spec)
 
2176
 
 
2177
    def _update_revisions(self, stop_revision=None, overwrite=False,
 
2178
                          graph=None):
 
2179
        with self.source.lock_read(), self.target.lock_write():
3198
2180
            other_revno, other_last_revision = self.source.last_revision_info()
3199
 
            stop_revno = None # unknown
 
2181
            stop_revno = None  # unknown
3200
2182
            if stop_revision is None:
3201
2183
                stop_revision = other_last_revision
3202
2184
                if _mod_revision.is_null(stop_revision):
3211
2193
            # case of having something to pull, and so that the check for
3212
2194
            # already merged can operate on the just fetched graph, which will
3213
2195
            # be cached in memory.
3214
 
            self.target.fetch(self.source, stop_revision)
 
2196
            self.fetch(stop_revision=stop_revision)
3215
2197
            # Check to see if one is an ancestor of the other
3216
2198
            if not overwrite:
3217
2199
                if graph is None:
3225
2207
                if graph is None:
3226
2208
                    graph = self.target.repository.get_graph()
3227
2209
                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)])
 
2210
                    self.target.last_revision_info()
 
2211
                stop_revno = graph.find_distance_to_null(
 
2212
                    stop_revision, [(other_last_revision, other_revno),
 
2213
                                    (this_last_revision, this_revno)])
3232
2214
            self.target.set_last_revision_info(stop_revno, stop_revision)
3233
 
        finally:
3234
 
            self.source.unlock()
3235
2215
 
3236
2216
    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):
 
2217
             possible_transports=None, run_hooks=True,
 
2218
             _override_hook_target=None, local=False,
 
2219
             tag_selector=None):
 
2220
        """Pull from source into self, updating my master if any.
 
2221
 
 
2222
        :param run_hooks: Private parameter - if false, this branch
 
2223
            is being called because it's the master of the primary branch,
 
2224
            so it should not run its hooks.
 
2225
        """
 
2226
        with cleanup.ExitStack() as exit_stack:
 
2227
            exit_stack.enter_context(self.target.lock_write())
 
2228
            bound_location = self.target.get_bound_location()
 
2229
            if local and not bound_location:
 
2230
                raise errors.LocalRequiresBoundBranch()
 
2231
            master_branch = None
 
2232
            source_is_master = False
 
2233
            if bound_location:
 
2234
                # bound_location comes from a config file, some care has to be
 
2235
                # taken to relate it to source.user_url
 
2236
                normalized = urlutils.normalize_url(bound_location)
 
2237
                try:
 
2238
                    relpath = self.source.user_transport.relpath(normalized)
 
2239
                    source_is_master = (relpath == '')
 
2240
                except (errors.PathNotChild, urlutils.InvalidURL):
 
2241
                    source_is_master = False
 
2242
            if not local and bound_location and not source_is_master:
 
2243
                # not pulling from master, so we need to update master.
 
2244
                master_branch = self.target.get_master_branch(
 
2245
                    possible_transports)
 
2246
                exit_stack.enter_context(master_branch.lock_write())
 
2247
            if master_branch:
 
2248
                # pull from source into master.
 
2249
                master_branch.pull(
 
2250
                    self.source, overwrite, stop_revision, run_hooks=False,
 
2251
                    tag_selector=tag_selector)
 
2252
            return self._pull(
 
2253
                overwrite, stop_revision, _hook_master=master_branch,
 
2254
                run_hooks=run_hooks,
 
2255
                _override_hook_target=_override_hook_target,
 
2256
                merge_tags_to_master=not source_is_master,
 
2257
                tag_selector=tag_selector)
 
2258
 
 
2259
    def push(self, overwrite=False, stop_revision=None, lossy=False,
 
2260
             _override_hook_source_branch=None, tag_selector=None):
 
2261
        """See InterBranch.push.
 
2262
 
 
2263
        This is the basic concrete implementation of push()
 
2264
 
 
2265
        :param _override_hook_source_branch: If specified, run the hooks
 
2266
            passing this Branch as the source, rather than self.  This is for
 
2267
            use of RemoteBranch, where push is delegated to the underlying
 
2268
            vfs-based Branch.
 
2269
        """
 
2270
        if lossy:
 
2271
            raise errors.LossyPushToSameVCS(self.source, self.target)
 
2272
        # TODO: Public option to disable running hooks - should be trivial but
 
2273
        # needs tests.
 
2274
 
 
2275
        def _run_hooks():
 
2276
            if _override_hook_source_branch:
 
2277
                result.source_branch = _override_hook_source_branch
 
2278
            for hook in Branch.hooks['post_push']:
 
2279
                hook(result)
 
2280
 
 
2281
        with self.source.lock_read(), self.target.lock_write():
 
2282
            bound_location = self.target.get_bound_location()
 
2283
            if bound_location and self.target.base != bound_location:
 
2284
                # there is a master branch.
 
2285
                #
 
2286
                # XXX: Why the second check?  Is it even supported for a branch
 
2287
                # to be bound to itself? -- mbp 20070507
 
2288
                master_branch = self.target.get_master_branch()
 
2289
                with master_branch.lock_write():
 
2290
                    # push into the master from the source branch.
 
2291
                    master_inter = InterBranch.get(self.source, master_branch)
 
2292
                    master_inter._basic_push(
 
2293
                        overwrite, stop_revision, tag_selector=tag_selector)
 
2294
                    # and push into the target branch from the source. Note
 
2295
                    # that we push from the source branch again, because it's
 
2296
                    # considered the highest bandwidth repository.
 
2297
                    result = self._basic_push(
 
2298
                        overwrite, stop_revision, tag_selector=tag_selector)
 
2299
                    result.master_branch = master_branch
 
2300
                    result.local_branch = self.target
 
2301
                    _run_hooks()
 
2302
            else:
 
2303
                master_branch = None
 
2304
                # no master branch
 
2305
                result = self._basic_push(
 
2306
                    overwrite, stop_revision, tag_selector=tag_selector)
 
2307
                # TODO: Why set master_branch and local_branch if there's no
 
2308
                # binding?  Maybe cleaner to just leave them unset? -- mbp
 
2309
                # 20070504
 
2310
                result.master_branch = self.target
 
2311
                result.local_branch = None
 
2312
                _run_hooks()
 
2313
            return result
 
2314
 
 
2315
    def _basic_push(self, overwrite, stop_revision, tag_selector=None):
 
2316
        """Basic implementation of push without bound branches or hooks.
 
2317
 
 
2318
        Must be called with source read locked and target write locked.
 
2319
        """
 
2320
        result = BranchPushResult()
 
2321
        result.source_branch = self.source
 
2322
        result.target_branch = self.target
 
2323
        result.old_revno, result.old_revid = self.target.last_revision_info()
 
2324
        overwrite = _fix_overwrite_type(overwrite)
 
2325
        if result.old_revid != stop_revision:
 
2326
            # We assume that during 'push' this repository is closer than
 
2327
            # the target.
 
2328
            graph = self.source.repository.get_graph(self.target.repository)
 
2329
            self._update_revisions(
 
2330
                stop_revision, overwrite=("history" in overwrite), graph=graph)
 
2331
        if self.source._push_should_merge_tags():
 
2332
            result.tag_updates, result.tag_conflicts = (
 
2333
                self.source.tags.merge_to(
 
2334
                    self.target.tags, "tags" in overwrite, selector=tag_selector))
 
2335
        self.update_references()
 
2336
        result.new_revno, result.new_revid = self.target.last_revision_info()
 
2337
        return result
 
2338
 
 
2339
    def _pull(self, overwrite=False, stop_revision=None,
 
2340
              possible_transports=None, _hook_master=None, run_hooks=True,
 
2341
              _override_hook_target=None, local=False,
 
2342
              merge_tags_to_master=True, tag_selector=None):
3239
2343
        """See Branch.pull.
3240
2344
 
 
2345
        This function is the core worker, used by GenericInterBranch.pull to
 
2346
        avoid duplication when pulling source->master and source->local.
 
2347
 
3241
2348
        :param _hook_master: Private parameter - set the branch to
3242
2349
            be supplied as the master to pull hooks.
3243
2350
        :param run_hooks: Private parameter - if false, this branch
3244
2351
            is being called because it's the master of the primary branch,
3245
2352
            so it should not run its hooks.
 
2353
            is being called because it's the master of the primary branch,
 
2354
            so it should not run its hooks.
3246
2355
        :param _override_hook_target: Private parameter - set the branch to be
3247
2356
            supplied as the target_branch to pull hooks.
3248
2357
        :param local: Only update the local branch, and not the bound branch.
3256
2365
            result.target_branch = self.target
3257
2366
        else:
3258
2367
            result.target_branch = _override_hook_target
3259
 
        self.source.lock_read()
3260
 
        try:
 
2368
        with self.source.lock_read():
3261
2369
            # We assume that during 'pull' the target repository is closer than
3262
2370
            # the source one.
3263
 
            self.source.update_references(self.target)
3264
2371
            graph = self.target.repository.get_graph(self.source.repository)
3265
 
            # TODO: Branch formats should have a flag that indicates 
 
2372
            # TODO: Branch formats should have a flag that indicates
3266
2373
            # that revno's are expensive, and pull() should honor that flag.
3267
2374
            # -- JRV20090506
3268
2375
            result.old_revno, result.old_revid = \
3269
2376
                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 
 
2377
            overwrite = _fix_overwrite_type(overwrite)
 
2378
            self._update_revisions(
 
2379
                stop_revision, overwrite=("history" in overwrite), graph=graph)
 
2380
            # TODO: The old revid should be specified when merging tags,
 
2381
            # so a tags implementation that versions tags can only
3274
2382
            # 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()
 
2383
            result.tag_updates, result.tag_conflicts = (
 
2384
                self.source.tags.merge_to(
 
2385
                    self.target.tags, "tags" in overwrite,
 
2386
                    ignore_master=not merge_tags_to_master,
 
2387
                    selector=tag_selector))
 
2388
            self.update_references()
 
2389
            result.new_revno, result.new_revid = (
 
2390
                self.target.last_revision_info())
3278
2391
            if _hook_master:
3279
2392
                result.master_branch = _hook_master
3280
2393
                result.local_branch = result.target_branch
3284
2397
            if run_hooks:
3285
2398
                for hook in Branch.hooks['post_pull']:
3286
2399
                    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()
 
2400
            return result
 
2401
 
 
2402
    def update_references(self):
 
2403
        if not getattr(self.source._format, 'supports_reference_locations', False):
 
2404
            return
 
2405
        reference_dict = self.source._get_all_reference_info()
 
2406
        if len(reference_dict) == 0:
 
2407
            return
 
2408
        old_base = self.source.base
 
2409
        new_base = self.target.base
 
2410
        target_reference_dict = self.target._get_all_reference_info()
 
2411
        for tree_path, (branch_location, file_id) in viewitems(reference_dict):
3331
2412
            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()
 
2413
                branch_location = urlutils.rebase_url(branch_location,
 
2414
                                                      old_base, new_base)
 
2415
            except urlutils.InvalidRebaseURLs:
 
2416
                # Fall back to absolute URL
 
2417
                branch_location = urlutils.join(old_base, branch_location)
 
2418
            target_reference_dict.setdefault(
 
2419
                tree_path, (branch_location, file_id))
 
2420
        self.target._set_all_reference_info(target_reference_dict)
3398
2421
 
3399
2422
 
3400
2423
InterBranch.register_optimiser(GenericInterBranch)
3401
 
InterBranch.register_optimiser(InterToBranch5)