/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2012 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
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
 
from __future__ import absolute_import
18
17
 
 
18
from cStringIO import StringIO
19
19
import sys
20
20
 
21
 
from . import errors
22
 
 
23
 
from .lazy_import import lazy_import
 
21
from bzrlib.lazy_import import lazy_import
24
22
lazy_import(globals(), """
25
 
import itertools
26
 
from breezy import (
27
 
    cleanup,
28
 
    config as _mod_config,
29
 
    debug,
30
 
    fetch,
31
 
    memorytree,
32
 
    repository,
33
 
    revision as _mod_revision,
34
 
    tag as _mod_tag,
35
 
    transport,
36
 
    ui,
37
 
    urlutils,
38
 
    )
39
 
from breezy.bzr import (
40
 
    remote,
41
 
    vf_search,
42
 
    )
43
 
from breezy.i18n import gettext, ngettext
 
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
    )
44
47
""")
45
48
 
46
 
from . import (
47
 
    controldir,
48
 
    registry,
49
 
    )
50
 
from .decorators import (
51
 
    only_raises,
52
 
    )
53
 
from .hooks import Hooks
54
 
from .inter import InterObject
55
 
from .lock import LogicalLockResult
56
 
from .sixish import (
57
 
    BytesIO,
58
 
    text_type,
59
 
    viewitems,
60
 
    )
61
 
from .trace import mutter, mutter_callsite, note, is_quiet
62
 
 
63
 
 
64
 
class UnstackableBranchFormat(errors.BzrError):
65
 
 
66
 
    _fmt = ("The branch '%(url)s'(%(format)s) is not a stackable format. "
67
 
        "You will need to upgrade the branch to permit branch stacking.")
68
 
 
69
 
    def __init__(self, format, url):
70
 
        errors.BzrError.__init__(self)
71
 
        self.format = format
72
 
        self.url = url
73
 
 
74
 
 
75
 
class Branch(controldir.ControlComponent):
 
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):
76
67
    """Branch holding a history of revisions.
77
68
 
78
69
    :ivar base:
79
70
        Base directory/url of the branch; using control_url and
80
71
        control_transport is more standardized.
81
 
    :ivar hooks: An instance of BranchHooks.
82
 
    :ivar _master_branch_cache: cached result of get_master_branch, see
83
 
        _clear_cached_state.
 
72
 
 
73
    hooks: An instance of BranchHooks.
84
74
    """
85
75
    # this is really an instance variable - FIXME move it there
86
76
    # - RBC 20060112
92
82
 
93
83
    @property
94
84
    def user_transport(self):
95
 
        return self.controldir.user_transport
 
85
        return self.bzrdir.user_transport
96
86
 
97
 
    def __init__(self, possible_transports=None):
 
87
    def __init__(self, *ignored, **ignored_too):
98
88
        self.tags = self._format.make_tags(self)
99
89
        self._revision_history_cache = None
100
90
        self._revision_id_to_revno_cache = None
101
91
        self._partial_revision_id_to_revno_cache = {}
102
92
        self._partial_revision_history_cache = []
103
93
        self._last_revision_info_cache = None
104
 
        self._master_branch_cache = None
105
94
        self._merge_sorted_revisions_cache = None
106
 
        self._open_hook(possible_transports)
 
95
        self._open_hook()
107
96
        hooks = Branch.hooks['open']
108
97
        for hook in hooks:
109
98
            hook(self)
110
99
 
111
 
    def _open_hook(self, possible_transports):
 
100
    def _open_hook(self):
112
101
        """Called by init to allow simpler extension of the base class."""
113
102
 
114
 
    def _activate_fallback_location(self, url, possible_transports):
 
103
    def _activate_fallback_location(self, url):
115
104
        """Activate the branch/repository from url as a fallback repository."""
116
 
        for existing_fallback_repo in self.repository._fallback_repositories:
117
 
            if existing_fallback_repo.user_url == url:
118
 
                # This fallback is already configured.  This probably only
119
 
                # happens because ControlDir.sprout is a horrible mess.  To
120
 
                # avoid confusing _unstack we don't add this a second time.
121
 
                mutter('duplicate activation of fallback %r on %r', url, self)
122
 
                return
123
 
        repo = self._get_fallback_repository(url, possible_transports)
 
105
        repo = self._get_fallback_repository(url)
124
106
        if repo.has_same_location(self.repository):
125
107
            raise errors.UnstackableLocationError(self.user_url, url)
126
108
        self.repository.add_fallback_repository(repo)
141
123
 
142
124
    def _check_stackable_repo(self):
143
125
        if not self.repository._format.supports_external_lookups:
144
 
            raise errors.UnstackableRepositoryFormat(
145
 
                self.repository._format, self.repository.base)
 
126
            raise errors.UnstackableRepositoryFormat(self.repository._format,
 
127
                self.repository.base)
146
128
 
147
129
    def _extend_partial_history(self, stop_index=None, stop_revision=None):
148
130
        """Extend the partial history to include a given index
168
150
    def _get_check_refs(self):
169
151
        """Get the references needed for check().
170
152
 
171
 
        See breezy.check.
 
153
        See bzrlib.check.
172
154
        """
173
155
        revid = self.last_revision()
174
156
        return [('revision-existence', revid), ('lefthand-distance', revid)]
180
162
        For instance, if the branch is at URL/.bzr/branch,
181
163
        Branch.open(URL) -> a Branch instance.
182
164
        """
183
 
        control = controldir.ControlDir.open(base,
184
 
            possible_transports=possible_transports, _unsupported=_unsupported)
185
 
        return control.open_branch(unsupported=_unsupported,
186
 
            possible_transports=possible_transports)
 
165
        control = bzrdir.BzrDir.open(base, _unsupported,
 
166
                                     possible_transports=possible_transports)
 
167
        return control.open_branch(unsupported=_unsupported)
187
168
 
188
169
    @staticmethod
189
 
    def open_from_transport(transport, name=None, _unsupported=False,
190
 
            possible_transports=None):
 
170
    def open_from_transport(transport, name=None, _unsupported=False):
191
171
        """Open the branch rooted at transport"""
192
 
        control = controldir.ControlDir.open_from_transport(transport, _unsupported)
193
 
        return control.open_branch(name=name, unsupported=_unsupported,
194
 
            possible_transports=possible_transports)
 
172
        control = bzrdir.BzrDir.open_from_transport(transport, _unsupported)
 
173
        return control.open_branch(name=name, unsupported=_unsupported)
195
174
 
196
175
    @staticmethod
197
176
    def open_containing(url, possible_transports=None):
205
184
        format, UnknownFormatError or UnsupportedFormatError are raised.
206
185
        If there is one, it is returned, along with the unused portion of url.
207
186
        """
208
 
        control, relpath = controldir.ControlDir.open_containing(url,
 
187
        control, relpath = bzrdir.BzrDir.open_containing(url,
209
188
                                                         possible_transports)
210
 
        branch = control.open_branch(possible_transports=possible_transports)
211
 
        return (branch, relpath)
 
189
        return control.open_branch(), relpath
212
190
 
213
191
    def _push_should_merge_tags(self):
214
192
        """Should _basic_push merge this branch's tags into the target?
219
197
        return self.supports_tags() and self.tags.get_tag_dict()
220
198
 
221
199
    def get_config(self):
222
 
        """Get a breezy.config.BranchConfig for this Branch.
223
 
 
224
 
        This can then be used to get and set configuration options for the
225
 
        branch.
226
 
 
227
 
        :return: A breezy.config.BranchConfig.
228
 
        """
229
 
        return _mod_config.BranchConfig(self)
230
 
 
231
 
    def get_config_stack(self):
232
 
        """Get a breezy.config.BranchStack for this Branch.
233
 
 
234
 
        This can then be used to get and set configuration options for the
235
 
        branch.
236
 
 
237
 
        :return: A breezy.config.BranchStack.
238
 
        """
239
 
        return _mod_config.BranchStack(self)
240
 
 
241
 
    def store_uncommitted(self, creator):
242
 
        """Store uncommitted changes from a ShelfCreator.
243
 
 
244
 
        :param creator: The ShelfCreator containing uncommitted changes, or
245
 
            None to delete any stored changes.
246
 
        :raises: ChangesAlreadyStored if the branch already has changes.
247
 
        """
248
 
        raise NotImplementedError(self.store_uncommitted)
249
 
 
250
 
    def get_unshelver(self, tree):
251
 
        """Return a shelf.Unshelver for this branch and tree.
252
 
 
253
 
        :param tree: The tree to use to construct the Unshelver.
254
 
        :return: an Unshelver or None if no changes are stored.
255
 
        """
256
 
        raise NotImplementedError(self.get_unshelver)
257
 
 
258
 
    def _get_fallback_repository(self, url, possible_transports):
 
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):
259
215
        """Get the repository we fallback to at url."""
260
216
        url = urlutils.join(self.base, url)
261
 
        a_branch = Branch.open(url, possible_transports=possible_transports)
 
217
        a_branch = Branch.open(url,
 
218
            possible_transports=[self.bzrdir.root_transport])
262
219
        return a_branch.repository
263
220
 
 
221
    def _get_tags_bytes(self):
 
222
        """Get the bytes of a serialised tags dict.
 
223
 
 
224
        Note that not all branches support tags, nor do all use the same tags
 
225
        logic: this method is specific to BasicTags. Other tag implementations
 
226
        may use the same method name and behave differently, safely, because
 
227
        of the double-dispatch via
 
228
        format.make_tags->tags_instance->get_tags_dict.
 
229
 
 
230
        :return: The bytes of the tags file.
 
231
        :seealso: Branch._set_tags_bytes.
 
232
        """
 
233
        return self._transport.get_bytes('tags')
 
234
 
264
235
    def _get_nick(self, local=False, possible_transports=None):
265
236
        config = self.get_config()
266
237
        # explicit overrides master, but don't look for master if local is True
267
238
        if not local and not config.has_explicit_nickname():
268
239
            try:
269
240
                master = self.get_master_branch(possible_transports)
270
 
                if master and self.user_url == master.user_url:
271
 
                    raise errors.RecursiveBind(self.user_url)
272
241
                if master is not None:
273
242
                    # return the master branch value
274
243
                    return master.nick
275
 
            except errors.RecursiveBind as e:
276
 
                raise e
277
 
            except errors.BzrError as e:
 
244
            except errors.BzrError, e:
278
245
                # Silently fall back to local implicit nick if the master is
279
246
                # unavailable
280
247
                mutter("Could not connect to bound branch, "
316
283
        new_history.reverse()
317
284
        return new_history
318
285
 
319
 
    def lock_write(self, token=None):
320
 
        """Lock the branch for write operations.
321
 
 
322
 
        :param token: A token to permit reacquiring a previously held and
323
 
            preserved lock.
324
 
        :return: A BranchWriteLockResult.
325
 
        """
 
286
    def lock_write(self):
326
287
        raise NotImplementedError(self.lock_write)
327
288
 
328
289
    def lock_read(self):
329
 
        """Lock the branch for read operations.
330
 
 
331
 
        :return: A breezy.lock.LogicalLockResult.
332
 
        """
333
290
        raise NotImplementedError(self.lock_read)
334
291
 
335
292
    def unlock(self):
342
299
    def get_physical_lock_status(self):
343
300
        raise NotImplementedError(self.get_physical_lock_status)
344
301
 
 
302
    @needs_read_lock
345
303
    def dotted_revno_to_revision_id(self, revno, _cache_reverse=False):
346
304
        """Return the revision_id for a dotted revno.
347
305
 
353
311
        :return: the revision_id
354
312
        :raises errors.NoSuchRevision: if the revno doesn't exist
355
313
        """
356
 
        with self.lock_read():
357
 
            rev_id = self._do_dotted_revno_to_revision_id(revno)
358
 
            if _cache_reverse:
359
 
                self._partial_revision_id_to_revno_cache[rev_id] = revno
360
 
            return rev_id
 
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
361
318
 
362
319
    def _do_dotted_revno_to_revision_id(self, revno):
363
320
        """Worker function for dotted_revno_to_revision_id.
369
326
            return self.get_rev_id(revno[0])
370
327
        revision_id_to_revno = self.get_revision_id_to_revno_map()
371
328
        revision_ids = [revision_id for revision_id, this_revno
372
 
                        in viewitems(revision_id_to_revno)
 
329
                        in revision_id_to_revno.iteritems()
373
330
                        if revno == this_revno]
374
331
        if len(revision_ids) == 1:
375
332
            return revision_ids[0]
377
334
            revno_str = '.'.join(map(str, revno))
378
335
            raise errors.NoSuchRevision(self, revno_str)
379
336
 
 
337
    @needs_read_lock
380
338
    def revision_id_to_dotted_revno(self, revision_id):
381
339
        """Given a revision id, return its dotted revno.
382
340
 
383
341
        :return: a tuple like (1,) or (400,1,3).
384
342
        """
385
 
        with self.lock_read():
386
 
            return self._do_revision_id_to_dotted_revno(revision_id)
 
343
        return self._do_revision_id_to_dotted_revno(revision_id)
387
344
 
388
345
    def _do_revision_id_to_dotted_revno(self, revision_id):
389
346
        """Worker function for revision_id_to_revno."""
406
363
                raise errors.NoSuchRevision(self, revision_id)
407
364
        return result
408
365
 
 
366
    @needs_read_lock
409
367
    def get_revision_id_to_revno_map(self):
410
368
        """Return the revision_id => dotted revno map.
411
369
 
414
372
        :return: A dictionary mapping revision_id => dotted revno.
415
373
            This dictionary should not be modified by the caller.
416
374
        """
417
 
        if 'evil' in debug.debug_flags:
418
 
            mutter_callsite(3, "get_revision_id_to_revno_map scales with ancestry.")
419
 
        with self.lock_read():
420
 
            if self._revision_id_to_revno_cache is not None:
421
 
                mapping = self._revision_id_to_revno_cache
422
 
            else:
423
 
                mapping = self._gen_revno_map()
424
 
                self._cache_revision_id_to_revno(mapping)
425
 
            # TODO: jam 20070417 Since this is being cached, should we be returning
426
 
            #       a copy?
427
 
            # I would rather not, and instead just declare that users should not
428
 
            # modify the return value.
429
 
            return mapping
 
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
430
385
 
431
386
    def _gen_revno_map(self):
432
387
        """Create a new mapping from revision ids to dotted revnos.
443
398
             in self.iter_merge_sorted_revisions())
444
399
        return revision_id_to_revno
445
400
 
 
401
    @needs_read_lock
446
402
    def iter_merge_sorted_revisions(self, start_revision_id=None,
447
403
            stop_revision_id=None, stop_rule='exclude', direction='reverse'):
448
404
        """Walk the revisions for a branch in merge sorted order.
457
413
            after. If None, the rest of history is included.
458
414
        :param stop_rule: if stop_revision_id is not None, the precise rule
459
415
            to use for termination:
460
 
 
461
416
            * 'exclude' - leave the stop revision out of the result (default)
462
417
            * 'include' - the stop revision is the last item in the result
463
418
            * 'with-merges' - include the stop revision and all of its
465
420
            * 'with-merges-without-common-ancestry' - filter out revisions 
466
421
              that are in both ancestries
467
422
        :param direction: either 'reverse' or 'forward':
468
 
 
469
423
            * reverse means return the start_revision_id first, i.e.
470
424
              start at the most recent revision and go backwards in history
471
425
            * forward returns tuples in the opposite order to reverse.
487
441
            * end_of_merge: When True the next node (earlier in history) is
488
442
              part of a different merge.
489
443
        """
490
 
        with self.lock_read():
491
 
            # Note: depth and revno values are in the context of the branch so
492
 
            # we need the full graph to get stable numbers, regardless of the
493
 
            # start_revision_id.
494
 
            if self._merge_sorted_revisions_cache is None:
495
 
                last_revision = self.last_revision()
496
 
                known_graph = self.repository.get_known_graph_ancestry(
497
 
                    [last_revision])
498
 
                self._merge_sorted_revisions_cache = known_graph.merge_sort(
499
 
                    last_revision)
500
 
            filtered = self._filter_merge_sorted_revisions(
501
 
                self._merge_sorted_revisions_cache, start_revision_id,
502
 
                stop_revision_id, stop_rule)
503
 
            # Make sure we don't return revisions that are not part of the
504
 
            # start_revision_id ancestry.
505
 
            filtered = self._filter_start_non_ancestors(filtered)
506
 
            if direction == 'reverse':
507
 
                return filtered
508
 
            if direction == 'forward':
509
 
                return reversed(list(filtered))
510
 
            else:
511
 
                raise ValueError('invalid direction %r' % direction)
 
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)
512
465
 
513
466
    def _filter_merge_sorted_revisions(self, merge_sorted_revisions,
514
467
        start_revision_id, stop_revision_id, stop_rule):
516
469
        rev_iter = iter(merge_sorted_revisions)
517
470
        if start_revision_id is not None:
518
471
            for node in rev_iter:
519
 
                rev_id = node.key
 
472
                rev_id = node.key[-1]
520
473
                if rev_id != start_revision_id:
521
474
                    continue
522
475
                else:
523
476
                    # The decision to include the start or not
524
477
                    # depends on the stop_rule if a stop is provided
525
478
                    # so pop this node back into the iterator
526
 
                    rev_iter = itertools.chain(iter([node]), rev_iter)
 
479
                    rev_iter = chain(iter([node]), rev_iter)
527
480
                    break
528
481
        if stop_revision_id is None:
529
482
            # Yield everything
530
483
            for node in rev_iter:
531
 
                rev_id = node.key
 
484
                rev_id = node.key[-1]
532
485
                yield (rev_id, node.merge_depth, node.revno,
533
486
                       node.end_of_merge)
534
487
        elif stop_rule == 'exclude':
535
488
            for node in rev_iter:
536
 
                rev_id = node.key
 
489
                rev_id = node.key[-1]
537
490
                if rev_id == stop_revision_id:
538
491
                    return
539
492
                yield (rev_id, node.merge_depth, node.revno,
540
493
                       node.end_of_merge)
541
494
        elif stop_rule == 'include':
542
495
            for node in rev_iter:
543
 
                rev_id = node.key
 
496
                rev_id = node.key[-1]
544
497
                yield (rev_id, node.merge_depth, node.revno,
545
498
                       node.end_of_merge)
546
499
                if rev_id == stop_revision_id:
552
505
            ancestors = graph.find_unique_ancestors(start_revision_id,
553
506
                                                    [stop_revision_id])
554
507
            for node in rev_iter:
555
 
                rev_id = node.key
 
508
                rev_id = node.key[-1]
556
509
                if rev_id not in ancestors:
557
510
                    continue
558
511
                yield (rev_id, node.merge_depth, node.revno,
568
521
            reached_stop_revision_id = False
569
522
            revision_id_whitelist = []
570
523
            for node in rev_iter:
571
 
                rev_id = node.key
 
524
                rev_id = node.key[-1]
572
525
                if rev_id == left_parent:
573
526
                    # reached the left parent after the stop_revision
574
527
                    return
591
544
        # ancestry. Given the order guaranteed by the merge sort, we will see
592
545
        # uninteresting descendants of the first parent of our tip before the
593
546
        # tip itself.
594
 
        try:
595
 
            first = next(rev_iter)
596
 
        except StopIteration:
597
 
            return
 
547
        first = rev_iter.next()
598
548
        (rev_id, merge_depth, revno, end_of_merge) = first
599
549
        yield first
600
550
        if not merge_depth:
657
607
        """
658
608
        raise errors.UpgradeRequired(self.user_url)
659
609
 
660
 
    def get_append_revisions_only(self):
661
 
        """Whether it is only possible to append revisions to the history.
662
 
        """
663
 
        if not self._format.supports_set_append_revisions_only():
664
 
            return False
665
 
        return self.get_config_stack().get('append_revisions_only')
666
 
 
667
610
    def set_append_revisions_only(self, enabled):
668
611
        if not self._format.supports_set_append_revisions_only():
669
612
            raise errors.UpgradeRequired(self.user_url)
670
 
        self.get_config_stack().set('append_revisions_only', enabled)
 
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)
671
619
 
672
 
    def set_reference_info(self, tree_path, branch_location, file_id=None):
 
620
    def set_reference_info(self, file_id, tree_path, branch_location):
673
621
        """Set the branch location to use for a tree reference."""
674
622
        raise errors.UnsupportedOperation(self.set_reference_info, self)
675
623
 
676
 
    def get_reference_info(self, path):
 
624
    def get_reference_info(self, file_id):
677
625
        """Get the tree_path and branch_location for a tree reference."""
678
626
        raise errors.UnsupportedOperation(self.get_reference_info, self)
679
627
 
680
 
    def fetch(self, from_branch, last_revision=None, limit=None):
 
628
    @needs_write_lock
 
629
    def fetch(self, from_branch, last_revision=None, pb=None):
681
630
        """Copy revisions from from_branch into this branch.
682
631
 
683
632
        :param from_branch: Where to copy from.
684
633
        :param last_revision: What revision to stop at (None for at the end
685
634
                              of the branch.
686
 
        :param limit: Optional rough limit of revisions to fetch
 
635
        :param pb: An optional progress bar to use.
687
636
        :return: None
688
637
        """
689
 
        with self.lock_write():
690
 
            return InterBranch.get(from_branch, self).fetch(
691
 
                    last_revision, limit=limit)
 
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()
692
654
 
693
655
    def get_bound_location(self):
694
656
        """Return the URL of the branch we are bound to.
703
665
        """
704
666
        raise errors.UpgradeRequired(self.user_url)
705
667
 
706
 
    def get_commit_builder(self, parents, config_stack=None, timestamp=None,
 
668
    def get_commit_builder(self, parents, config=None, timestamp=None,
707
669
                           timezone=None, committer=None, revprops=None,
708
 
                           revision_id=None, lossy=False):
 
670
                           revision_id=None):
709
671
        """Obtain a CommitBuilder for this branch.
710
672
 
711
673
        :param parents: Revision ids of the parents of the new revision.
715
677
        :param committer: Optional committer to set for commit.
716
678
        :param revprops: Optional dictionary of revision properties.
717
679
        :param revision_id: Optional revision id.
718
 
        :param lossy: Whether to discard data that can not be natively
719
 
            represented, when pushing to a foreign VCS 
720
680
        """
721
681
 
722
 
        if config_stack is None:
723
 
            config_stack = self.get_config_stack()
 
682
        if config is None:
 
683
            config = self.get_config()
724
684
 
725
 
        return self.repository.get_commit_builder(self, parents, config_stack,
726
 
            timestamp, timezone, committer, revprops, revision_id,
727
 
            lossy)
 
685
        return self.repository.get_commit_builder(self, parents, config,
 
686
            timestamp, timezone, committer, revprops, revision_id)
728
687
 
729
688
    def get_master_branch(self, possible_transports=None):
730
689
        """Return the branch we are bound to.
733
692
        """
734
693
        return None
735
694
 
 
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
 
736
706
    def get_stacked_on_url(self):
737
707
        """Get the URL this branch is stacked against.
738
708
 
742
712
        """
743
713
        raise NotImplementedError(self.get_stacked_on_url)
744
714
 
745
 
    def set_last_revision_info(self, revno, revision_id):
746
 
        """Set the last revision of this branch.
747
 
 
748
 
        The caller is responsible for checking that the revno is correct
749
 
        for this revision id.
750
 
 
751
 
        It may be possible to set the branch last revision to an id not
752
 
        present in the repository.  However, branches can also be
753
 
        configured to check constraints on history, in which case this may not
754
 
        be permitted.
755
 
        """
756
 
        raise NotImplementedError(self.set_last_revision_info)
757
 
 
758
 
    def generate_revision_history(self, revision_id, last_rev=None,
759
 
                                  other_branch=None):
760
 
        """See Branch.generate_revision_history"""
761
 
        with self.lock_write():
762
 
            graph = self.repository.get_graph()
763
 
            (last_revno, last_revid) = self.last_revision_info()
764
 
            known_revision_ids = [
765
 
                (last_revid, last_revno),
766
 
                (_mod_revision.NULL_REVISION, 0),
767
 
                ]
768
 
            if last_rev is not None:
769
 
                if not graph.is_ancestor(last_rev, revision_id):
770
 
                    # our previous tip is not merged into stop_revision
771
 
                    raise errors.DivergedBranches(self, other_branch)
772
 
            revno = graph.find_distance_to_null(revision_id, known_revision_ids)
773
 
            self.set_last_revision_info(revno, revision_id)
774
 
 
 
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
775
723
    def set_parent(self, url):
776
724
        """See Branch.set_parent."""
777
725
        # TODO: Maybe delete old location files?
779
727
        # FIXUP this and get_parent in a future branch format bump:
780
728
        # read and rewrite the file. RBC 20060125
781
729
        if url is not None:
782
 
            # TODO(jelmer): Clean this up for pad.lv/1696545
783
 
            if isinstance(url, text_type) and sys.version_info[0] == 2:
 
730
            if isinstance(url, unicode):
784
731
                try:
785
732
                    url = url.encode('ascii')
786
733
                except UnicodeEncodeError:
787
 
                    raise urlutils.InvalidURL(url,
 
734
                    raise errors.InvalidURL(url,
788
735
                        "Urls must be 7-bit ascii, "
789
 
                        "use breezy.urlutils.escape")
 
736
                        "use bzrlib.urlutils.escape")
790
737
            url = urlutils.relative_url(self.base, url)
791
 
        with self.lock_write():
792
 
            self._set_parent_location(url)
 
738
        self._set_parent_location(url)
793
739
 
 
740
    @needs_write_lock
794
741
    def set_stacked_on_url(self, url):
795
742
        """Set the URL this branch is stacked against.
796
743
 
800
747
            stacking.
801
748
        """
802
749
        if not self._format.supports_stacking():
803
 
            raise UnstackableBranchFormat(self._format, self.user_url)
804
 
        with self.lock_write():
805
 
            # XXX: Changing from one fallback repository to another does not check
806
 
            # that all the data you need is present in the new fallback.
807
 
            # Possibly it should.
808
 
            self._check_stackable_repo()
809
 
            if not url:
810
 
                try:
811
 
                    old_url = self.get_stacked_on_url()
812
 
                except (errors.NotStacked, UnstackableBranchFormat,
813
 
                    errors.UnstackableRepositoryFormat):
814
 
                    return
815
 
                self._unstack()
816
 
            else:
817
 
                self._activate_fallback_location(url,
818
 
                    possible_transports=[self.controldir.root_transport])
819
 
            # write this out after the repository is stacked to avoid setting a
820
 
            # stacked config that doesn't work.
821
 
            self._set_config_location('stacked_on_location', url)
 
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)
822
767
 
823
768
    def _unstack(self):
824
769
        """Change a branch to be unstacked, copying data as needed.
825
 
 
 
770
        
826
771
        Don't call this directly, use set_stacked_on_url(None).
827
772
        """
828
 
        with ui.ui_factory.nested_progress_bar() as pb:
829
 
            pb.update(gettext("Unstacking"))
 
773
        pb = ui.ui_factory.nested_progress_bar()
 
774
        try:
 
775
            pb.update("Unstacking")
830
776
            # The basic approach here is to fetch the tip of the branch,
831
777
            # including all available ghosts, from the existing stacked
832
778
            # repository into a new repository object without the fallbacks. 
836
782
            old_repository = self.repository
837
783
            if len(old_repository._fallback_repositories) != 1:
838
784
                raise AssertionError("can't cope with fallback repositories "
839
 
                    "of %r (fallbacks: %r)" % (old_repository,
840
 
                        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("didn't expect %r to have "
854
 
                    "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()
 
785
                    "of %r" % (self.repository,))
 
786
            # unlock it, including unlocking the fallback
869
787
            old_repository.unlock()
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):
 
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
888
807
                self.repository.lock_write()
889
 
            # Fetch from the old repository into the new.
890
 
            with old_repository.lock_read():
891
808
                # XXX: If you unstack a branch while it has a working tree
892
809
                # with a pending merge, the pending-merged revisions will no
893
810
                # longer be present.  You can (probably) revert and remerge.
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(self.repository,
899
 
                    old_repository, required_ids=[self.last_revision()],
900
 
                    if_present_ids=tags_to_fetch, find_ghosts=True).execute()
901
 
                self.repository.fetch(old_repository, fetch_spec=fetch_spec)
 
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)
902
830
 
903
831
    def _cache_revision_history(self, rev_history):
904
832
        """Set the cached revision history to rev_history.
925
853
        This means the next call to revision_history will need to call
926
854
        _gen_revision_history.
927
855
 
928
 
        This API is semi-public; it is only for use by subclasses, all other
929
 
        code should consider it to be private.
 
856
        This API is semi-public; it only for use by subclasses, all other code
 
857
        should consider it to be private.
930
858
        """
931
859
        self._revision_history_cache = None
932
860
        self._revision_id_to_revno_cache = None
933
861
        self._last_revision_info_cache = None
934
 
        self._master_branch_cache = None
935
862
        self._merge_sorted_revisions_cache = None
936
863
        self._partial_revision_history_cache = []
937
864
        self._partial_revision_id_to_revno_cache = {}
951
878
        """
952
879
        raise NotImplementedError(self._gen_revision_history)
953
880
 
954
 
    def _revision_history(self):
 
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
888
        if 'evil' in debug.debug_flags:
956
889
            mutter_callsite(3, "revision_history scales with history.")
957
890
        if self._revision_history_cache is not None:
977
910
        """Return last revision id, or NULL_REVISION."""
978
911
        return self.last_revision_info()[1]
979
912
 
 
913
    @needs_read_lock
980
914
    def last_revision_info(self):
981
915
        """Return information about the last revision.
982
916
 
983
917
        :return: A tuple (revno, revision_id).
984
918
        """
985
 
        with self.lock_read():
986
 
            if self._last_revision_info_cache is None:
987
 
                self._last_revision_info_cache = self._read_last_revision_info()
988
 
            return self._last_revision_info_cache
989
 
 
990
 
    def _read_last_revision_info(self):
991
 
        raise NotImplementedError(self._read_last_revision_info)
992
 
 
993
 
    def import_last_revision_info_and_tags(self, source, revno, revid,
994
 
                                           lossy=False):
 
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):
995
971
        """Set the last revision info, importing from another repo if necessary.
996
972
 
997
973
        This is used by the bound branch code to upload a revision to
998
974
        the master branch first before updating the tip of the local branch.
999
 
        Revisions referenced by source's tags are also transferred.
1000
975
 
1001
 
        :param source: Source branch to optionally fetch from
 
976
        :param source_repo: Source repository to optionally fetch from
1002
977
        :param revno: Revision number of the new tip
1003
978
        :param revid: Revision id of the new tip
1004
 
        :param lossy: Whether to discard metadata that can not be
1005
 
            natively represented
1006
 
        :return: Tuple with the new revision number and revision id
1007
 
            (should only be different from the arguments when lossy=True)
1008
979
        """
1009
 
        if not self.repository.has_same_location(source.repository):
1010
 
            self.fetch(source, revid)
 
980
        if not self.repository.has_same_location(source_repo):
 
981
            self.repository.fetch(source_repo, revision_id=revid)
1011
982
        self.set_last_revision_info(revno, revid)
1012
 
        return (revno, revid)
1013
983
 
1014
984
    def revision_id_to_revno(self, revision_id):
1015
985
        """Given a revision id, return its revno"""
1016
986
        if _mod_revision.is_null(revision_id):
1017
987
            return 0
1018
 
        history = self._revision_history()
 
988
        history = self.revision_history()
1019
989
        try:
1020
990
            return history.index(revision_id) + 1
1021
991
        except ValueError:
1022
992
            raise errors.NoSuchRevision(self, revision_id)
1023
993
 
 
994
    @needs_read_lock
1024
995
    def get_rev_id(self, revno, history=None):
1025
996
        """Find the revision id of the specified revno."""
1026
 
        with self.lock_read():
1027
 
            if revno == 0:
1028
 
                return _mod_revision.NULL_REVISION
1029
 
            last_revno, last_revid = self.last_revision_info()
1030
 
            if revno == last_revno:
1031
 
                return last_revid
1032
 
            if revno <= 0 or revno > last_revno:
1033
 
                raise errors.NoSuchRevision(self, revno)
1034
 
            distance_from_last = last_revno - revno
1035
 
            if len(self._partial_revision_history_cache) <= distance_from_last:
1036
 
                self._extend_partial_history(distance_from_last)
1037
 
            return self._partial_revision_history_cache[distance_from_last]
 
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]
1038
1008
 
 
1009
    @needs_write_lock
1039
1010
    def pull(self, source, overwrite=False, stop_revision=None,
1040
1011
             possible_transports=None, *args, **kwargs):
1041
1012
        """Mirror source into this branch.
1048
1019
            stop_revision=stop_revision,
1049
1020
            possible_transports=possible_transports, *args, **kwargs)
1050
1021
 
1051
 
    def push(self, target, overwrite=False, stop_revision=None, lossy=False,
1052
 
            *args, **kwargs):
 
1022
    def push(self, target, overwrite=False, stop_revision=None, *args,
 
1023
        **kwargs):
1053
1024
        """Mirror this branch into target.
1054
1025
 
1055
1026
        This branch is considered to be 'local', having low latency.
1056
1027
        """
1057
1028
        return InterBranch.get(self, target).push(overwrite, stop_revision,
1058
 
            lossy, *args, **kwargs)
 
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
1051
 
1060
1052
    def basis_tree(self):
1061
1053
        """Return `Tree` object for last revision."""
1077
1069
            parent = urlutils.local_path_to_url(parent.decode('utf8'))
1078
1070
        try:
1079
1071
            return urlutils.join(self.base[:-1], parent)
1080
 
        except urlutils.InvalidURLJoin as e:
 
1072
        except errors.InvalidURLJoin, e:
1081
1073
            raise errors.InaccessibleParent(parent, self.user_url)
1082
1074
 
1083
1075
    def _get_parent_location(self):
1086
1078
    def _set_config_location(self, name, url, config=None,
1087
1079
                             make_relative=False):
1088
1080
        if config is None:
1089
 
            config = self.get_config_stack()
 
1081
            config = self.get_config()
1090
1082
        if url is None:
1091
1083
            url = ''
1092
1084
        elif make_relative:
1093
1085
            url = urlutils.relative_url(self.base, url)
1094
 
        config.set(name, url)
 
1086
        config.set_user_option(name, url, warn_masked=True)
1095
1087
 
1096
1088
    def _get_config_location(self, name, config=None):
1097
1089
        if config is None:
1098
 
            config = self.get_config_stack()
1099
 
        location = config.get(name)
 
1090
            config = self.get_config()
 
1091
        location = config.get_user_option(name)
1100
1092
        if location == '':
1101
1093
            location = None
1102
1094
        return location
1103
1095
 
1104
1096
    def get_child_submit_format(self):
1105
1097
        """Return the preferred format of submissions to this branch."""
1106
 
        return self.get_config_stack().get('child_submit_format')
 
1098
        return self.get_config().get_user_option("child_submit_format")
1107
1099
 
1108
1100
    def get_submit_branch(self):
1109
1101
        """Return the submit location of the branch.
1112
1104
        pattern is that the user can override it by specifying a
1113
1105
        location.
1114
1106
        """
1115
 
        return self.get_config_stack().get('submit_branch')
 
1107
        return self.get_config().get_user_option('submit_branch')
1116
1108
 
1117
1109
    def set_submit_branch(self, location):
1118
1110
        """Return the submit location of the branch.
1121
1113
        pattern is that the user can override it by specifying a
1122
1114
        location.
1123
1115
        """
1124
 
        self.get_config_stack().set('submit_branch', location)
 
1116
        self.get_config().set_user_option('submit_branch', location,
 
1117
            warn_masked=True)
1125
1118
 
1126
1119
    def get_public_branch(self):
1127
1120
        """Return the public location of the branch.
1140
1133
        self._set_config_location('public_branch', location)
1141
1134
 
1142
1135
    def get_push_location(self):
1143
 
        """Return None or the location to push this branch to."""
1144
 
        return self.get_config_stack().get('push_location')
 
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
1139
 
1146
1140
    def set_push_location(self, location):
1147
1141
        """Set a new push location for this branch."""
1169
1163
        for hook in hooks:
1170
1164
            hook(params)
1171
1165
 
 
1166
    @needs_write_lock
1172
1167
    def update(self):
1173
1168
        """Synchronise this branch with the master branch if any.
1174
1169
 
1192
1187
        if revno < 1 or revno > self.revno():
1193
1188
            raise errors.InvalidRevisionNumber(revno)
1194
1189
 
1195
 
    def clone(self, to_controldir, revision_id=None, repository_policy=None):
1196
 
        """Clone this branch into to_controldir preserving all semantic values.
 
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
1193
 
1198
1194
        Most API users will want 'create_clone_on_transport', which creates a
1199
1195
        new bzrdir and branch on the fly.
1201
1197
        revision_id: if not None, the revision history in the new branch will
1202
1198
                     be truncated to end with revision_id.
1203
1199
        """
1204
 
        result = to_controldir.create_branch()
1205
 
        with self.lock_read(), result.lock_write():
 
1200
        result = to_bzrdir.create_branch()
 
1201
        result.lock_write()
 
1202
        try:
1206
1203
            if repository_policy is not None:
1207
1204
                repository_policy.configure_branch(result)
1208
1205
            self.copy_content_into(result, revision_id=revision_id)
 
1206
        finally:
 
1207
            result.unlock()
1209
1208
        return result
1210
1209
 
1211
 
    def sprout(self, to_controldir, revision_id=None, repository_policy=None,
1212
 
            repository=None, lossy=False):
1213
 
        """Create a new line of development from the branch, into to_controldir.
 
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.
1214
1213
 
1215
 
        to_controldir controls the branch format.
 
1214
        to_bzrdir controls the branch format.
1216
1215
 
1217
1216
        revision_id: if not None, the revision history in the new branch will
1218
1217
                     be truncated to end with revision_id.
1219
1218
        """
1220
1219
        if (repository_policy is not None and
1221
1220
            repository_policy.requires_stacking()):
1222
 
            to_controldir._format.require_stacking(_skip_repo=True)
1223
 
        result = to_controldir.create_branch(repository=repository)
1224
 
        if lossy:
1225
 
            raise errors.LossyPushToSameVCS(self, result)
1226
 
        with self.lock_read(), result.lock_write():
 
1221
            to_bzrdir._format.require_stacking(_skip_repo=True)
 
1222
        result = to_bzrdir.create_branch()
 
1223
        result.lock_write()
 
1224
        try:
1227
1225
            if repository_policy is not None:
1228
1226
                repository_policy.configure_branch(result)
1229
1227
            self.copy_content_into(result, revision_id=revision_id)
1230
 
            master_url = self.get_bound_location()
1231
 
            if master_url is None:
1232
 
                result.set_parent(self.user_url)
1233
 
            else:
1234
 
                result.set_parent(master_url)
 
1228
            result.set_parent(self.bzrdir.root_transport.base)
 
1229
        finally:
 
1230
            result.unlock()
1235
1231
        return result
1236
1232
 
1237
1233
    def _synchronize_history(self, destination, revision_id):
1259
1255
                revno = 1
1260
1256
        destination.set_last_revision_info(revno, revision_id)
1261
1257
 
 
1258
    @needs_read_lock
1262
1259
    def copy_content_into(self, destination, revision_id=None):
1263
1260
        """Copy the content of self into destination.
1264
1261
 
1265
1262
        revision_id: if not None, the revision history in the new branch will
1266
1263
                     be truncated to end with revision_id.
1267
1264
        """
1268
 
        return InterBranch.get(self, destination).copy_content_into(
1269
 
            revision_id=revision_id)
 
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)
1270
1276
 
1271
1277
    def update_references(self, target):
1272
1278
        if not getattr(self._format, 'supports_reference_locations', False):
1277
1283
        old_base = self.base
1278
1284
        new_base = target.base
1279
1285
        target_reference_dict = target._get_all_reference_info()
1280
 
        for tree_path, (branch_location, file_id) in viewitems(reference_dict):
 
1286
        for file_id, (tree_path, branch_location) in (
 
1287
            reference_dict.items()):
1281
1288
            branch_location = urlutils.rebase_url(branch_location,
1282
1289
                                                  old_base, new_base)
1283
1290
            target_reference_dict.setdefault(
1284
 
                tree_path, (branch_location, file_id))
 
1291
                file_id, (tree_path, branch_location))
1285
1292
        target._set_all_reference_info(target_reference_dict)
1286
1293
 
 
1294
    @needs_read_lock
1287
1295
    def check(self, refs):
1288
1296
        """Check consistency of the branch.
1289
1297
 
1297
1305
            branch._get_check_refs()
1298
1306
        :return: A BranchCheckResult.
1299
1307
        """
1300
 
        with self.lock_read():
1301
 
            result = BranchCheckResult(self)
1302
 
            last_revno, last_revision_id = self.last_revision_info()
1303
 
            actual_revno = refs[('lefthand-distance', last_revision_id)]
1304
 
            if actual_revno != last_revno:
1305
 
                result.errors.append(errors.BzrCheckError(
1306
 
                    'revno does not match len(mainline) %s != %s' % (
1307
 
                    last_revno, actual_revno)))
1308
 
            # TODO: We should probably also check that self.revision_history
1309
 
            # matches the repository for older branch formats.
1310
 
            # If looking for the code that cross-checks repository parents against
1311
 
            # the Graph.iter_lefthand_ancestry output, that is now a repository
1312
 
            # specific check.
1313
 
            return result
 
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
1314
1321
 
1315
 
    def _get_checkout_format(self, lightweight=False):
 
1322
    def _get_checkout_format(self):
1316
1323
        """Return the most suitable metadir for a checkout of this branch.
1317
1324
        Weaves are used if this branch's repository uses weaves.
1318
1325
        """
1319
 
        format = self.repository.controldir.checkout_metadir()
1320
 
        format.set_branch_format(self._format)
 
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)
1321
1333
        return format
1322
1334
 
1323
1335
    def create_clone_on_transport(self, to_transport, revision_id=None,
1324
 
        stacked_on=None, create_prefix=False, use_existing_dir=False,
1325
 
        no_tree=None):
 
1336
        stacked_on=None, create_prefix=False, use_existing_dir=False):
1326
1337
        """Create a clone of this branch and its bzrdir.
1327
1338
 
1328
1339
        :param to_transport: The transport to clone onto.
1335
1346
        """
1336
1347
        # XXX: Fix the bzrdir API to allow getting the branch back from the
1337
1348
        # clone call. Or something. 20090224 RBC/spiv.
1338
 
        # XXX: Should this perhaps clone colocated branches as well, 
1339
 
        # rather than just the default branch? 20100319 JRV
1340
1349
        if revision_id is None:
1341
1350
            revision_id = self.last_revision()
1342
 
        dir_to = self.controldir.clone_on_transport(to_transport,
 
1351
        dir_to = self.bzrdir.clone_on_transport(to_transport,
1343
1352
            revision_id=revision_id, stacked_on=stacked_on,
1344
 
            create_prefix=create_prefix, use_existing_dir=use_existing_dir,
1345
 
            no_tree=no_tree)
 
1353
            create_prefix=create_prefix, use_existing_dir=use_existing_dir)
1346
1354
        return dir_to.open_branch()
1347
1355
 
1348
1356
    def create_checkout(self, to_location, revision_id=None,
1353
1361
        :param to_location: The url to produce the checkout at
1354
1362
        :param revision_id: The revision to check out
1355
1363
        :param lightweight: If True, produce a lightweight checkout, otherwise,
1356
 
            produce a bound branch (heavyweight checkout)
 
1364
        produce a bound branch (heavyweight checkout)
1357
1365
        :param accelerator_tree: A tree which can be used for retrieving file
1358
1366
            contents more quickly than the revision tree, i.e. a workingtree.
1359
1367
            The revision tree will be used for cases where accelerator_tree's
1364
1372
        """
1365
1373
        t = transport.get_transport(to_location)
1366
1374
        t.ensure_base()
1367
 
        format = self._get_checkout_format(lightweight=lightweight)
1368
 
        try:
 
1375
        if lightweight:
 
1376
            format = self._get_checkout_format()
1369
1377
            checkout = format.initialize_on_transport(t)
1370
 
        except errors.AlreadyControlDirError:
1371
 
            # It's fine if the control directory already exists,
1372
 
            # as long as there is no existing branch and working tree.
1373
 
            checkout = controldir.ControlDir.open_from_transport(t)
1374
 
            try:
1375
 
                checkout.open_branch()
1376
 
            except errors.NotBranchError:
1377
 
                pass
1378
 
            else:
1379
 
                raise errors.AlreadyControlDirError(t.base)
1380
 
            if checkout.control_transport.base == self.controldir.control_transport.base:
1381
 
                # When checking out to the same control directory,
1382
 
                # always create a lightweight checkout
1383
 
                lightweight = True
1384
 
 
1385
 
        if lightweight:
1386
 
            from_branch = checkout.set_branch_reference(target_branch=self)
 
1378
            from_branch = BranchReferenceFormat().initialize(checkout, 
 
1379
                target_branch=self)
1387
1380
        else:
1388
 
            policy = checkout.determine_repository_policy()
1389
 
            repo = policy.acquire_repository()[0]
1390
 
            checkout_branch = checkout.create_branch()
 
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
1391
1385
            checkout_branch.bind(self)
1392
1386
            # pull up to the specified revision_id to set the initial
1393
1387
            # branch tip correctly, and seed it with history.
1394
1388
            checkout_branch.pull(self, stop_revision=revision_id)
1395
 
            from_branch = None
 
1389
            from_branch=None
1396
1390
        tree = checkout.create_workingtree(revision_id,
1397
1391
                                           from_branch=from_branch,
1398
1392
                                           accelerator_tree=accelerator_tree,
1399
1393
                                           hardlink=hardlink)
1400
1394
        basis_tree = tree.basis_tree()
1401
 
        with basis_tree.lock_read():
 
1395
        basis_tree.lock_read()
 
1396
        try:
1402
1397
            for path, file_id in basis_tree.iter_references():
1403
 
                reference_parent = self.reference_parent(path, file_id)
 
1398
                reference_parent = self.reference_parent(file_id, path)
1404
1399
                reference_parent.create_checkout(tree.abspath(path),
1405
 
                    basis_tree.get_reference_revision(path, file_id),
 
1400
                    basis_tree.get_reference_revision(file_id, path),
1406
1401
                    lightweight)
 
1402
        finally:
 
1403
            basis_tree.unlock()
1407
1404
        return tree
1408
1405
 
 
1406
    @needs_write_lock
1409
1407
    def reconcile(self, thorough=True):
1410
1408
        """Make sure the data stored in this branch is consistent."""
1411
 
        from breezy.reconcile import BranchReconciler
1412
 
        with self.lock_write():
1413
 
            reconciler = BranchReconciler(self, thorough=thorough)
1414
 
            reconciler.reconcile()
1415
 
            return reconciler
 
1409
        from bzrlib.reconcile import BranchReconciler
 
1410
        reconciler = BranchReconciler(self, thorough=thorough)
 
1411
        reconciler.reconcile()
 
1412
        return reconciler
1416
1413
 
1417
 
    def reference_parent(self, path, file_id=None, possible_transports=None):
 
1414
    def reference_parent(self, file_id, path, possible_transports=None):
1418
1415
        """Return the parent branch for a tree-reference file_id
1419
 
 
 
1416
        :param file_id: The file_id of the tree reference
1420
1417
        :param path: The path of the file_id in the tree
1421
 
        :param file_id: Optional file_id of the tree reference
1422
1418
        :return: A branch associated with the file_id
1423
1419
        """
1424
1420
        # FIXME should provide multiple branches, based on config
1425
 
        return Branch.open(self.controldir.root_transport.clone(path).base,
 
1421
        return Branch.open(self.bzrdir.root_transport.clone(path).base,
1426
1422
                           possible_transports=possible_transports)
1427
1423
 
1428
1424
    def supports_tags(self):
1465
1461
        :returns: One of: 'a_descends_from_b', 'b_descends_from_a', 'diverged'
1466
1462
        """
1467
1463
        heads = graph.heads([revision_a, revision_b])
1468
 
        if heads == {revision_b}:
 
1464
        if heads == set([revision_b]):
1469
1465
            return 'b_descends_from_a'
1470
 
        elif heads == {revision_a, revision_b}:
 
1466
        elif heads == set([revision_a, revision_b]):
1471
1467
            # These branches have diverged
1472
1468
            return 'diverged'
1473
 
        elif heads == {revision_a}:
 
1469
        elif heads == set([revision_a]):
1474
1470
            return 'a_descends_from_b'
1475
1471
        else:
1476
1472
            raise AssertionError("invalid heads: %r" % (heads,))
1477
1473
 
1478
 
    def heads_to_fetch(self):
1479
 
        """Return the heads that must and that should be fetched to copy this
1480
 
        branch into another repo.
1481
 
 
1482
 
        :returns: a 2-tuple of (must_fetch, if_present_fetch).  must_fetch is a
1483
 
            set of heads that must be fetched.  if_present_fetch is a set of
1484
 
            heads that must be fetched if present, but no error is necessary if
1485
 
            they are not present.
1486
 
        """
1487
 
        # For bzr native formats must_fetch is just the tip, and
1488
 
        # if_present_fetch are the tags.
1489
 
        must_fetch = {self.last_revision()}
1490
 
        if_present_fetch = set()
1491
 
        if self.get_config_stack().get('branch.fetch_tags'):
1492
 
            try:
1493
 
                if_present_fetch = set(self.tags.get_reverse_tag_dict())
1494
 
            except errors.TagsNotSupported:
1495
 
                pass
1496
 
        must_fetch.discard(_mod_revision.NULL_REVISION)
1497
 
        if_present_fetch.discard(_mod_revision.NULL_REVISION)
1498
 
        return must_fetch, if_present_fetch
1499
 
 
1500
 
    def create_memorytree(self):
1501
 
        """Create a memory tree for this branch.
1502
 
 
1503
 
        :return: An in-memory MutableTree instance
1504
 
        """
1505
 
        return memorytree.MemoryTree.create_on_branch(self)
1506
 
 
1507
 
 
1508
 
class BranchFormat(controldir.ControlComponentFormat):
 
1474
 
 
1475
class BranchFormat(object):
1509
1476
    """An encapsulation of the initialization and open routines for a format.
1510
1477
 
1511
1478
    Formats provide three things:
1512
1479
     * An initialization routine,
1513
 
     * a format description
 
1480
     * a format string,
1514
1481
     * an open routine.
1515
1482
 
1516
1483
    Formats are placed in an dict by their format string for reference
1517
 
    during branch opening. It's not required that these be instances, they
 
1484
    during branch opening. Its not required that these be instances, they
1518
1485
    can be classes themselves with class methods - it simply depends on
1519
1486
    whether state is needed for a given format or not.
1520
1487
 
1523
1490
    object will be created every time regardless.
1524
1491
    """
1525
1492
 
 
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
 
1526
1501
    def __eq__(self, other):
1527
1502
        return self.__class__ is other.__class__
1528
1503
 
1529
1504
    def __ne__(self, other):
1530
1505
        return not (self == other)
1531
1506
 
1532
 
    def get_reference(self, controldir, name=None):
1533
 
        """Get the target reference of the branch in controldir.
 
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.
1534
1526
 
1535
1527
        format probing must have been completed before calling
1536
1528
        this method - it is assumed that the format of the branch
1537
 
        in controldir is correct.
 
1529
        in a_bzrdir is correct.
1538
1530
 
1539
 
        :param controldir: The controldir to get the branch data from.
1540
 
        :param name: Name of the colocated branch to fetch
 
1531
        :param a_bzrdir: The bzrdir to get the branch data from.
1541
1532
        :return: None if the branch is not a reference branch.
1542
1533
        """
1543
1534
        return None
1544
1535
 
1545
1536
    @classmethod
1546
 
    def set_reference(self, controldir, name, to_branch):
1547
 
        """Set the target reference of the branch in controldir.
 
1537
    def set_reference(self, a_bzrdir, to_branch):
 
1538
        """Set the target reference of the branch in a_bzrdir.
1548
1539
 
1549
1540
        format probing must have been completed before calling
1550
1541
        this method - it is assumed that the format of the branch
1551
 
        in controldir is correct.
 
1542
        in a_bzrdir is correct.
1552
1543
 
1553
 
        :param controldir: The controldir to set the branch reference for.
1554
 
        :param name: Name of colocated branch to set, None for default
 
1544
        :param a_bzrdir: The bzrdir to set the branch reference for.
1555
1545
        :param to_branch: branch that the checkout is to reference
1556
1546
        """
1557
1547
        raise NotImplementedError(self.set_reference)
1558
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
 
1559
1553
    def get_format_description(self):
1560
1554
        """Return the short format description for this format."""
1561
1555
        raise NotImplementedError(self.get_format_description)
1562
1556
 
1563
 
    def _run_post_branch_init_hooks(self, controldir, name, branch):
 
1557
    def _run_post_branch_init_hooks(self, a_bzrdir, name, branch):
1564
1558
        hooks = Branch.hooks['post_branch_init']
1565
1559
        if not hooks:
1566
1560
            return
1567
 
        params = BranchInitHookParams(self, controldir, name, branch)
 
1561
        params = BranchInitHookParams(self, a_bzrdir, name, branch)
1568
1562
        for hook in hooks:
1569
1563
            hook(params)
1570
1564
 
1571
 
    def initialize(self, controldir, name=None, repository=None,
1572
 
                   append_revisions_only=None):
1573
 
        """Create a branch of this format in controldir.
1574
 
 
 
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
        
1575
1613
        :param name: Name of the colocated branch to create.
1576
1614
        """
1577
1615
        raise NotImplementedError(self.initialize)
1597
1635
        Note that it is normal for branch to be a RemoteBranch when using tags
1598
1636
        on a RemoteBranch.
1599
1637
        """
1600
 
        return _mod_tag.DisabledTags(branch)
 
1638
        return DisabledTags(branch)
1601
1639
 
1602
1640
    def network_name(self):
1603
1641
        """A simple byte string uniquely identifying this format for RPC calls.
1609
1647
        """
1610
1648
        raise NotImplementedError(self.network_name)
1611
1649
 
1612
 
    def open(self, controldir, name=None, _found=False, ignore_fallbacks=False,
1613
 
            found_repository=None, possible_transports=None):
1614
 
        """Return the branch object for controldir.
 
1650
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
 
1651
        """Return the branch object for a_bzrdir
1615
1652
 
1616
 
        :param controldir: A ControlDir that contains a branch.
 
1653
        :param a_bzrdir: A BzrDir that contains a branch.
1617
1654
        :param name: Name of colocated branch to open
1618
1655
        :param _found: a private parameter, do not use it. It is used to
1619
1656
            indicate if format probing has already be done.
1622
1659
        """
1623
1660
        raise NotImplementedError(self.open)
1624
1661
 
 
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
 
1625
1674
    def supports_set_append_revisions_only(self):
1626
1675
        """True if this format supports set_append_revisions_only."""
1627
1676
        return False
1630
1679
        """True if this format records a stacked-on branch."""
1631
1680
        return False
1632
1681
 
1633
 
    def supports_leaving_lock(self):
1634
 
        """True if this format supports leaving locks in place."""
1635
 
        return False # by default
 
1682
    @classmethod
 
1683
    def unregister_format(klass, format):
 
1684
        del klass._formats[format.get_format_string()]
1636
1685
 
1637
1686
    def __str__(self):
1638
1687
        return self.get_format_description().rstrip()
1641
1690
        """True if this format supports tags stored in the branch"""
1642
1691
        return False  # by default
1643
1692
 
1644
 
    def tags_are_versioned(self):
1645
 
        """Whether the tag container for this branch versions tags."""
1646
 
        return False
1647
 
 
1648
 
    def supports_tags_referencing_ghosts(self):
1649
 
        """True if tags can reference ghost revisions."""
1650
 
        return True
1651
 
 
1652
 
    def supports_store_uncommitted(self):
1653
 
        """True if uncommitted changes can be stored in this branch."""
1654
 
        return True
1655
 
 
1656
1693
 
1657
1694
class BranchHooks(Hooks):
1658
1695
    """A dictionary mapping hook name to a list of callables for branch hooks.
1659
1696
 
1660
 
    e.g. ['post_push'] Is the list of items to be called when the
1661
 
    push function is invoked.
 
1697
    e.g. ['set_rh'] Is the list of items to be called when the
 
1698
    set_revision_history function is invoked.
1662
1699
    """
1663
1700
 
1664
1701
    def __init__(self):
1667
1704
        These are all empty initially, because by default nothing should get
1668
1705
        notified.
1669
1706
        """
1670
 
        Hooks.__init__(self, "breezy.branch", "Branch.hooks")
1671
 
        self.add_hook('open',
 
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',
1672
1715
            "Called with the Branch object that has been opened after a "
1673
 
            "branch is opened.", (1, 8))
1674
 
        self.add_hook('post_push',
 
1716
            "branch is opened.", (1, 8), None))
 
1717
        self.create_hook(HookPoint('post_push',
1675
1718
            "Called after a push operation completes. post_push is called "
1676
 
            "with a breezy.branch.BranchPushResult object and only runs in the "
1677
 
            "bzr client.", (0, 15))
1678
 
        self.add_hook('post_pull',
 
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',
1679
1722
            "Called after a pull operation completes. post_pull is called "
1680
 
            "with a breezy.branch.PullResult object and only runs in the "
1681
 
            "bzr client.", (0, 15))
1682
 
        self.add_hook('pre_commit',
1683
 
            "Called after a commit is calculated but before it is "
 
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 "
1684
1727
            "completed. pre_commit is called with (local, master, old_revno, "
1685
1728
            "old_revid, future_revno, future_revid, tree_delta, future_tree"
1686
1729
            "). old_revid is NULL_REVISION for the first commit to a branch, "
1688
1731
            "basis revision. hooks MUST NOT modify this delta. "
1689
1732
            " future_tree is an in-memory tree obtained from "
1690
1733
            "CommitBuilder.revision_tree() and hooks MUST NOT modify this "
1691
 
            "tree.", (0, 91))
1692
 
        self.add_hook('post_commit',
 
1734
            "tree.", (0,91), None))
 
1735
        self.create_hook(HookPoint('post_commit',
1693
1736
            "Called in the bzr client after a commit has completed. "
1694
1737
            "post_commit is called with (local, master, old_revno, old_revid, "
1695
1738
            "new_revno, new_revid). old_revid is NULL_REVISION for the first "
1696
 
            "commit to a branch.", (0, 15))
1697
 
        self.add_hook('post_uncommit',
 
1739
            "commit to a branch.", (0, 15), None))
 
1740
        self.create_hook(HookPoint('post_uncommit',
1698
1741
            "Called in the bzr client after an uncommit completes. "
1699
1742
            "post_uncommit is called with (local, master, old_revno, "
1700
1743
            "old_revid, new_revno, new_revid) where local is the local branch "
1701
1744
            "or None, master is the target branch, and an empty branch "
1702
 
            "receives new_revno of 0, new_revid of None.", (0, 15))
1703
 
        self.add_hook('pre_change_branch_tip',
 
1745
            "receives new_revno of 0, new_revid of None.", (0, 15), None))
 
1746
        self.create_hook(HookPoint('pre_change_branch_tip',
1704
1747
            "Called in bzr client and server before a change to the tip of a "
1705
1748
            "branch is made. pre_change_branch_tip is called with a "
1706
 
            "breezy.branch.ChangeBranchTipParams. Note that push, pull, "
1707
 
            "commit, uncommit will all trigger this hook.", (1, 6))
1708
 
        self.add_hook('post_change_branch_tip',
 
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',
1709
1752
            "Called in bzr client and server after a change to the tip of a "
1710
1753
            "branch is made. post_change_branch_tip is called with a "
1711
 
            "breezy.branch.ChangeBranchTipParams. Note that push, pull, "
1712
 
            "commit, uncommit will all trigger this hook.", (1, 4))
1713
 
        self.add_hook('transform_fallback_location',
 
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',
1714
1757
            "Called when a stacked branch is activating its fallback "
1715
1758
            "locations. transform_fallback_location is called with (branch, "
1716
1759
            "url), and should return a new url. Returning the same url "
1721
1764
            "fallback locations have not been activated. When there are "
1722
1765
            "multiple hooks installed for transform_fallback_location, "
1723
1766
            "all are called with the url returned from the previous hook."
1724
 
            "The order is however undefined.", (1, 9))
1725
 
        self.add_hook('automatic_tag_name',
1726
 
            "Called to determine an automatic tag name for a revision. "
 
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
1770
            "automatic_tag_name is called with (branch, revision_id) and "
1728
1771
            "should return a tag name or None if no tag name could be "
1729
1772
            "determined. The first non-None tag name returned will be used.",
1730
 
            (2, 2))
1731
 
        self.add_hook('post_branch_init',
 
1773
            (2, 2), None))
 
1774
        self.create_hook(HookPoint('post_branch_init',
1732
1775
            "Called after new branch initialization completes. "
1733
1776
            "post_branch_init is called with a "
1734
 
            "breezy.branch.BranchInitHookParams. "
 
1777
            "bzrlib.branch.BranchInitHookParams. "
1735
1778
            "Note that init, branch and checkout (both heavyweight and "
1736
 
            "lightweight) will all trigger this hook.", (2, 2))
1737
 
        self.add_hook('post_switch',
 
1779
            "lightweight) will all trigger this hook.", (2, 2), None))
 
1780
        self.create_hook(HookPoint('post_switch',
1738
1781
            "Called after a checkout switches branch. "
1739
1782
            "post_switch is called with a "
1740
 
            "breezy.branch.SwitchHookParams.", (2, 2))
 
1783
            "bzrlib.branch.SwitchHookParams.", (2, 2), None))
1741
1784
 
1742
1785
 
1743
1786
 
1746
1789
 
1747
1790
 
1748
1791
class ChangeBranchTipParams(object):
1749
 
    """Object holding parameters passed to `*_change_branch_tip` hooks.
 
1792
    """Object holding parameters passed to *_change_branch_tip hooks.
1750
1793
 
1751
1794
    There are 5 fields that hooks may wish to access:
1752
1795
 
1784
1827
 
1785
1828
 
1786
1829
class BranchInitHookParams(object):
1787
 
    """Object holding parameters passed to `*_branch_init` hooks.
 
1830
    """Object holding parameters passed to *_branch_init hooks.
1788
1831
 
1789
1832
    There are 4 fields that hooks may wish to access:
1790
1833
 
1791
1834
    :ivar format: the branch format
1792
 
    :ivar bzrdir: the ControlDir where the branch will be/has been initialized
 
1835
    :ivar bzrdir: the BzrDir where the branch will be/has been initialized
1793
1836
    :ivar name: name of colocated branch, if any (or None)
1794
1837
    :ivar branch: the branch created
1795
1838
 
1798
1841
    branch, which refer to the original branch.
1799
1842
    """
1800
1843
 
1801
 
    def __init__(self, format, controldir, name, branch):
 
1844
    def __init__(self, format, a_bzrdir, name, branch):
1802
1845
        """Create a group of BranchInitHook parameters.
1803
1846
 
1804
1847
        :param format: the branch format
1805
 
        :param controldir: the ControlDir where the branch will be/has been
 
1848
        :param a_bzrdir: the BzrDir where the branch will be/has been
1806
1849
            initialized
1807
1850
        :param name: name of colocated branch, if any (or None)
1808
1851
        :param branch: the branch created
1812
1855
        in branch, which refer to the original branch.
1813
1856
        """
1814
1857
        self.format = format
1815
 
        self.controldir = controldir
 
1858
        self.bzrdir = a_bzrdir
1816
1859
        self.name = name
1817
1860
        self.branch = branch
1818
1861
 
1820
1863
        return self.__dict__ == other.__dict__
1821
1864
 
1822
1865
    def __repr__(self):
1823
 
        return "<%s of %s>" % (self.__class__.__name__, self.branch)
 
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)
1824
1872
 
1825
1873
 
1826
1874
class SwitchHookParams(object):
1827
 
    """Object holding parameters passed to `*_switch` hooks.
 
1875
    """Object holding parameters passed to *_switch hooks.
1828
1876
 
1829
1877
    There are 4 fields that hooks may wish to access:
1830
1878
 
1831
 
    :ivar control_dir: ControlDir of the checkout to change
 
1879
    :ivar control_dir: BzrDir of the checkout to change
1832
1880
    :ivar to_branch: branch that the checkout is to reference
1833
1881
    :ivar force: skip the check for local commits in a heavy checkout
1834
1882
    :ivar revision_id: revision ID to switch to (or None)
1837
1885
    def __init__(self, control_dir, to_branch, force, revision_id):
1838
1886
        """Create a group of SwitchHook parameters.
1839
1887
 
1840
 
        :param control_dir: ControlDir of the checkout to change
 
1888
        :param control_dir: BzrDir of the checkout to change
1841
1889
        :param to_branch: branch that the checkout is to reference
1842
1890
        :param force: skip the check for local commits in a heavy checkout
1843
1891
        :param revision_id: revision ID to switch to (or None)
1856
1904
            self.revision_id)
1857
1905
 
1858
1906
 
1859
 
class BranchFormatRegistry(controldir.ControlComponentFormatRegistry):
1860
 
    """Branch format registry."""
1861
 
 
1862
 
    def __init__(self, other_registry=None):
1863
 
        super(BranchFormatRegistry, self).__init__(other_registry)
1864
 
        self._default_format = None
1865
 
        self._default_format_key = None
1866
 
 
1867
 
    def get_default(self):
1868
 
        """Return the current default format."""
1869
 
        if (self._default_format_key is not None and
1870
 
            self._default_format is None):
1871
 
            self._default_format = self.get(self._default_format_key)
1872
 
        return self._default_format
1873
 
 
1874
 
    def set_default(self, format):
1875
 
        """Set the default format."""
1876
 
        self._default_format = format
1877
 
        self._default_format_key = None
1878
 
 
1879
 
    def set_default_key(self, format_string):
1880
 
        """Set the default format by its format string."""
1881
 
        self._default_format_key = format_string
1882
 
        self._default_format = None
 
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
1883
2239
 
1884
2240
 
1885
2241
network_format_registry = registry.FormatRegistry()
1890
2246
BranchFormat.network_name() for more detail.
1891
2247
"""
1892
2248
 
1893
 
format_registry = BranchFormatRegistry(network_format_registry)
1894
 
 
1895
2249
 
1896
2250
# formats which have no format string are not discoverable
1897
2251
# and not independently creatable, so are not registered.
1898
 
format_registry.register_lazy(
1899
 
    b"Bazaar-NG branch format 5\n", "breezy.bzr.fullhistory",
1900
 
    "BzrBranchFormat5")
1901
 
format_registry.register_lazy(
1902
 
    b"Bazaar Branch Format 6 (bzr 0.15)\n",
1903
 
    "breezy.bzr.branch", "BzrBranchFormat6")
1904
 
format_registry.register_lazy(
1905
 
    b"Bazaar Branch Format 7 (needs bzr 1.6)\n",
1906
 
    "breezy.bzr.branch", "BzrBranchFormat7")
1907
 
format_registry.register_lazy(
1908
 
    b"Bazaar Branch Format 8 (needs bzr 1.15)\n",
1909
 
    "breezy.bzr.branch", "BzrBranchFormat8")
1910
 
format_registry.register_lazy(
1911
 
    b"Bazaar-NG Branch Reference Format 1\n",
1912
 
    "breezy.bzr.branch", "BranchReferenceFormat")
1913
 
 
1914
 
format_registry.set_default_key(b"Bazaar Branch Format 7 (needs bzr 1.6)\n")
1915
 
 
1916
 
 
1917
 
class BranchWriteLockResult(LogicalLockResult):
1918
 
    """The result of write locking a branch.
1919
 
 
1920
 
    :ivar token: The token obtained from the underlying branch lock, or
1921
 
        None.
1922
 
    :ivar unlock: A callable which will unlock the lock.
1923
 
    """
1924
 
 
1925
 
    def __repr__(self):
1926
 
        return "BranchWriteLockResult(%r, %r)" % (self.unlock, self.token)
 
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)
1927
2955
 
1928
2956
 
1929
2957
######################################################################
1953
2981
    :ivar local_branch: target branch if there is a Master, else None
1954
2982
    :ivar target_branch: Target/destination branch object. (write locked)
1955
2983
    :ivar tag_conflicts: A list of tag conflicts, see BasicTags.merge_to
1956
 
    :ivar tag_updates: A dict with new tags, see BasicTags.merge_to
1957
2984
    """
1958
2985
 
 
2986
    def __int__(self):
 
2987
        # DEPRECATED: pull used to return the change in revno
 
2988
        return self.new_revno - self.old_revno
 
2989
 
1959
2990
    def report(self, to_file):
1960
 
        tag_conflicts = getattr(self, "tag_conflicts", None)
1961
 
        tag_updates = getattr(self, "tag_updates", None)
1962
2991
        if not is_quiet():
1963
 
            if self.old_revid != self.new_revid:
 
2992
            if self.old_revid == self.new_revid:
 
2993
                to_file.write('No revisions to pull.\n')
 
2994
            else:
1964
2995
                to_file.write('Now on revision %d.\n' % self.new_revno)
1965
 
            if tag_updates:
1966
 
                to_file.write('%d tag(s) updated.\n' % len(tag_updates))
1967
 
            if self.old_revid == self.new_revid and not tag_updates:
1968
 
                if not tag_conflicts:
1969
 
                    to_file.write('No revisions or tags to pull.\n')
1970
 
                else:
1971
 
                    to_file.write('No revisions to pull.\n')
1972
2996
        self._show_tag_conficts(to_file)
1973
2997
 
1974
2998
 
1991
3015
        target, otherwise it will be None.
1992
3016
    """
1993
3017
 
 
3018
    def __int__(self):
 
3019
        # DEPRECATED: push used to return the change in revno
 
3020
        return self.new_revno - self.old_revno
 
3021
 
1994
3022
    def report(self, to_file):
1995
 
        # TODO: This function gets passed a to_file, but then
1996
 
        # ignores it and calls note() instead. This is also
1997
 
        # inconsistent with PullResult(), which writes to stdout.
1998
 
        # -- JRV20110901, bug #838853
1999
 
        tag_conflicts = getattr(self, "tag_conflicts", None)
2000
 
        tag_updates = getattr(self, "tag_updates", None)
2001
 
        if not is_quiet():
2002
 
            if self.old_revid != self.new_revid:
2003
 
                note(gettext('Pushed up to revision %d.') % self.new_revno)
2004
 
            if tag_updates:
2005
 
                note(ngettext('%d tag updated.', '%d tags updated.', len(tag_updates)) % len(tag_updates))
2006
 
            if self.old_revid == self.new_revid and not tag_updates:
2007
 
                if not tag_conflicts:
2008
 
                    note(gettext('No new revisions or tags to push.'))
2009
 
                else:
2010
 
                    note(gettext('No new revisions to push.'))
 
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)
2011
3028
        self._show_tag_conficts(to_file)
2012
3029
 
2013
3030
 
2027
3044
        :param verbose: Requests more detailed display of what was checked,
2028
3045
            if any.
2029
3046
        """
2030
 
        note(gettext('checked branch {0} format {1}').format(
2031
 
                                self.branch.user_url, self.branch._format))
 
3047
        note('checked branch %s format %s', self.branch.user_url,
 
3048
            self.branch._format)
2032
3049
        for error in self.errors:
2033
 
            note(gettext('found error:%s'), error)
 
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
2034
3135
 
2035
3136
 
2036
3137
class InterBranch(InterObject):
2044
3145
    _optimisers = []
2045
3146
    """The available optimised InterBranch types."""
2046
3147
 
2047
 
    @classmethod
2048
 
    def _get_branch_formats_to_test(klass):
2049
 
        """Return an iterable of format tuples for testing.
2050
 
        
2051
 
        :return: An iterable of (from_format, to_format) to use when testing
2052
 
            this InterBranch class. Each InterBranch class should define this
2053
 
            method itself.
2054
 
        """
2055
 
        raise NotImplementedError(klass._get_branch_formats_to_test)
 
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)
2056
3152
 
2057
3153
    def pull(self, overwrite=False, stop_revision=None,
2058
3154
             possible_transports=None, local=False):
2064
3160
        """
2065
3161
        raise NotImplementedError(self.pull)
2066
3162
 
2067
 
    def push(self, overwrite=False, stop_revision=None, lossy=False,
 
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,
2068
3177
             _override_hook_source_branch=None):
2069
3178
        """Mirror the source branch into the target branch.
2070
3179
 
2072
3181
        """
2073
3182
        raise NotImplementedError(self.push)
2074
3183
 
2075
 
    def copy_content_into(self, revision_id=None):
2076
 
        """Copy the content of source into target
2077
 
 
2078
 
        revision_id: if not None, the revision history in the new branch will
2079
 
                     be truncated to end with revision_id.
2080
 
        """
2081
 
        raise NotImplementedError(self.copy_content_into)
2082
 
 
2083
 
    def fetch(self, stop_revision=None, limit=None):
2084
 
        """Fetch revisions.
2085
 
 
2086
 
        :param stop_revision: Last revision to fetch
2087
 
        :param limit: Optional rough limit of revisions to fetch
2088
 
        """
2089
 
        raise NotImplementedError(self.fetch)
2090
 
 
2091
 
 
2092
 
def _fix_overwrite_type(overwrite):
2093
 
    if isinstance(overwrite, bool):
2094
 
        if overwrite:
2095
 
            return ["history", "tags"]
2096
 
        else:
2097
 
            return []
2098
 
    return overwrite
2099
 
 
2100
3184
 
2101
3185
class GenericInterBranch(InterBranch):
2102
 
    """InterBranch implementation that uses public Branch functions."""
2103
 
 
2104
 
    @classmethod
2105
 
    def is_compatible(klass, source, target):
2106
 
        # GenericBranch uses the public API, so always compatible
2107
 
        return True
2108
 
 
2109
 
    @classmethod
2110
 
    def _get_branch_formats_to_test(klass):
2111
 
        return [(format_registry.get_default(), format_registry.get_default())]
2112
 
 
2113
 
    @classmethod
2114
 
    def unwrap_format(klass, format):
2115
 
        if isinstance(format, remote.RemoteBranchFormat):
2116
 
            format._ensure_real()
2117
 
            return format._custom_format
2118
 
        return format
2119
 
 
2120
 
    def copy_content_into(self, revision_id=None):
2121
 
        """Copy the content of source into target
2122
 
 
2123
 
        revision_id: if not None, the revision history in the new branch will
2124
 
                     be truncated to end with revision_id.
2125
 
        """
2126
 
        with self.source.lock_read(), self.target.lock_write():
2127
 
            self.source.update_references(self.target)
2128
 
            self.source._synchronize_history(self.target, revision_id)
2129
 
            try:
2130
 
                parent = self.source.get_parent()
2131
 
            except errors.InaccessibleParent as e:
2132
 
                mutter('parent was not accessible to copy: %s', str(e))
2133
 
            else:
2134
 
                if parent:
2135
 
                    self.target.set_parent(parent)
2136
 
            if self.source._push_should_merge_tags():
2137
 
                self.source.tags.merge_to(self.target.tags)
2138
 
 
2139
 
    def fetch(self, stop_revision=None, limit=None):
2140
 
        if self.target.base == self.source.base:
2141
 
            return (0, [])
2142
 
        with self.source.lock_read(), self.target.lock_write():
2143
 
            fetch_spec_factory = fetch.FetchSpecFactory()
2144
 
            fetch_spec_factory.source_branch = self.source
2145
 
            fetch_spec_factory.source_branch_stop_revision_id = stop_revision
2146
 
            fetch_spec_factory.source_repo = self.source.repository
2147
 
            fetch_spec_factory.target_repo = self.target.repository
2148
 
            fetch_spec_factory.target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
2149
 
            fetch_spec_factory.limit = limit
2150
 
            fetch_spec = fetch_spec_factory.make_fetch_spec()
2151
 
            return self.target.repository.fetch(
2152
 
                    self.source.repository,
2153
 
                    fetch_spec=fetch_spec)
2154
 
 
2155
 
    def _update_revisions(self, stop_revision=None, overwrite=False,
2156
 
            graph=None):
2157
 
        with self.source.lock_read(), self.target.lock_write():
 
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:
2158
3198
            other_revno, other_last_revision = self.source.last_revision_info()
2159
3199
            stop_revno = None # unknown
2160
3200
            if stop_revision is None:
2171
3211
            # case of having something to pull, and so that the check for
2172
3212
            # already merged can operate on the just fetched graph, which will
2173
3213
            # be cached in memory.
2174
 
            self.fetch(stop_revision=stop_revision)
 
3214
            self.target.fetch(self.source, stop_revision)
2175
3215
            # Check to see if one is an ancestor of the other
2176
3216
            if not overwrite:
2177
3217
                if graph is None:
2190
3230
                                [(other_last_revision, other_revno),
2191
3231
                                 (this_last_revision, this_revno)])
2192
3232
            self.target.set_last_revision_info(stop_revno, stop_revision)
 
3233
        finally:
 
3234
            self.source.unlock()
2193
3235
 
2194
3236
    def pull(self, overwrite=False, stop_revision=None,
2195
 
             possible_transports=None, run_hooks=True,
2196
 
             _override_hook_target=None, local=False):
2197
 
        """Pull from source into self, updating my master if any.
2198
 
 
2199
 
        :param run_hooks: Private parameter - if false, this branch
2200
 
            is being called because it's the master of the primary branch,
2201
 
            so it should not run its hooks.
2202
 
        """
2203
 
        with self.target.lock_write():
2204
 
            bound_location = self.target.get_bound_location()
2205
 
            if local and not bound_location:
2206
 
                raise errors.LocalRequiresBoundBranch()
2207
 
            master_branch = None
2208
 
            source_is_master = False
2209
 
            if bound_location:
2210
 
                # bound_location comes from a config file, some care has to be
2211
 
                # taken to relate it to source.user_url
2212
 
                normalized = urlutils.normalize_url(bound_location)
2213
 
                try:
2214
 
                    relpath = self.source.user_transport.relpath(normalized)
2215
 
                    source_is_master = (relpath == '')
2216
 
                except (errors.PathNotChild, urlutils.InvalidURL):
2217
 
                    source_is_master = False
2218
 
            if not local and bound_location and not source_is_master:
2219
 
                # not pulling from master, so we need to update master.
2220
 
                master_branch = self.target.get_master_branch(possible_transports)
2221
 
                master_branch.lock_write()
2222
 
            try:
2223
 
                if master_branch:
2224
 
                    # pull from source into master.
2225
 
                    master_branch.pull(self.source, overwrite, stop_revision,
2226
 
                        run_hooks=False)
2227
 
                return self._pull(overwrite,
2228
 
                    stop_revision, _hook_master=master_branch,
2229
 
                    run_hooks=run_hooks,
2230
 
                    _override_hook_target=_override_hook_target,
2231
 
                    merge_tags_to_master=not source_is_master)
2232
 
            finally:
2233
 
                if master_branch:
2234
 
                    master_branch.unlock()
2235
 
 
2236
 
    def push(self, overwrite=False, stop_revision=None, lossy=False,
2237
 
             _override_hook_source_branch=None):
2238
 
        """See InterBranch.push.
2239
 
 
2240
 
        This is the basic concrete implementation of push()
2241
 
 
2242
 
        :param _override_hook_source_branch: If specified, run the hooks
2243
 
            passing this Branch as the source, rather than self.  This is for
2244
 
            use of RemoteBranch, where push is delegated to the underlying
2245
 
            vfs-based Branch.
2246
 
        """
2247
 
        if lossy:
2248
 
            raise errors.LossyPushToSameVCS(self.source, self.target)
2249
 
        # TODO: Public option to disable running hooks - should be trivial but
2250
 
        # needs tests.
2251
 
        def _run_hooks():
2252
 
            if _override_hook_source_branch:
2253
 
                result.source_branch = _override_hook_source_branch
2254
 
            for hook in Branch.hooks['post_push']:
2255
 
                hook(result)
2256
 
 
2257
 
        with self.source.lock_read(), self.target.lock_write():
2258
 
            bound_location = self.target.get_bound_location()
2259
 
            if bound_location and self.target.base != bound_location:
2260
 
                # there is a master branch.
2261
 
                #
2262
 
                # XXX: Why the second check?  Is it even supported for a branch to
2263
 
                # be bound to itself? -- mbp 20070507
2264
 
                master_branch = self.target.get_master_branch()
2265
 
                with master_branch.lock_write():
2266
 
                    # push into the master from the source branch.
2267
 
                    master_inter = InterBranch.get(self.source, master_branch)
2268
 
                    master_inter._basic_push(overwrite, stop_revision)
2269
 
                    # and push into the target branch from the source. Note that
2270
 
                    # we push from the source branch again, because it's considered
2271
 
                    # the highest bandwidth repository.
2272
 
                    result = self._basic_push(overwrite, stop_revision)
2273
 
                    result.master_branch = master_branch
2274
 
                    result.local_branch = self.target
2275
 
                    _run_hooks()
2276
 
            else:
2277
 
                master_branch = None
2278
 
                # no master branch
2279
 
                result = self._basic_push(overwrite, stop_revision)
2280
 
                # TODO: Why set master_branch and local_branch if there's no
2281
 
                # binding?  Maybe cleaner to just leave them unset? -- mbp
2282
 
                # 20070504
2283
 
                result.master_branch = self.target
2284
 
                result.local_branch = None
2285
 
                _run_hooks()
2286
 
            return result
2287
 
 
2288
 
    def _basic_push(self, overwrite, stop_revision):
2289
 
        """Basic implementation of push without bound branches or hooks.
2290
 
 
2291
 
        Must be called with source read locked and target write locked.
2292
 
        """
2293
 
        result = BranchPushResult()
2294
 
        result.source_branch = self.source
2295
 
        result.target_branch = self.target
2296
 
        result.old_revno, result.old_revid = self.target.last_revision_info()
2297
 
        self.source.update_references(self.target)
2298
 
        overwrite = _fix_overwrite_type(overwrite)
2299
 
        if result.old_revid != stop_revision:
2300
 
            # We assume that during 'push' this repository is closer than
2301
 
            # the target.
2302
 
            graph = self.source.repository.get_graph(self.target.repository)
2303
 
            self._update_revisions(stop_revision,
2304
 
                overwrite=("history" in overwrite),
2305
 
                graph=graph)
2306
 
        if self.source._push_should_merge_tags():
2307
 
            result.tag_updates, result.tag_conflicts = (
2308
 
                self.source.tags.merge_to(
2309
 
                self.target.tags, "tags" in overwrite))
2310
 
        result.new_revno, result.new_revid = self.target.last_revision_info()
2311
 
        return result
2312
 
 
2313
 
    def _pull(self, overwrite=False, stop_revision=None,
2314
3237
             possible_transports=None, _hook_master=None, run_hooks=True,
2315
 
             _override_hook_target=None, local=False,
2316
 
             merge_tags_to_master=True):
 
3238
             _override_hook_target=None, local=False):
2317
3239
        """See Branch.pull.
2318
3240
 
2319
 
        This function is the core worker, used by GenericInterBranch.pull to
2320
 
        avoid duplication when pulling source->master and source->local.
2321
 
 
2322
3241
        :param _hook_master: Private parameter - set the branch to
2323
3242
            be supplied as the master to pull hooks.
2324
3243
        :param run_hooks: Private parameter - if false, this branch
2325
3244
            is being called because it's the master of the primary branch,
2326
3245
            so it should not run its hooks.
2327
 
            is being called because it's the master of the primary branch,
2328
 
            so it should not run its hooks.
2329
3246
        :param _override_hook_target: Private parameter - set the branch to be
2330
3247
            supplied as the target_branch to pull hooks.
2331
3248
        :param local: Only update the local branch, and not the bound branch.
2339
3256
            result.target_branch = self.target
2340
3257
        else:
2341
3258
            result.target_branch = _override_hook_target
2342
 
        with self.source.lock_read():
 
3259
        self.source.lock_read()
 
3260
        try:
2343
3261
            # We assume that during 'pull' the target repository is closer than
2344
3262
            # the source one.
2345
3263
            self.source.update_references(self.target)
2349
3267
            # -- JRV20090506
2350
3268
            result.old_revno, result.old_revid = \
2351
3269
                self.target.last_revision_info()
2352
 
            overwrite = _fix_overwrite_type(overwrite)
2353
 
            self._update_revisions(stop_revision,
2354
 
                overwrite=("history" in overwrite),
2355
 
                graph=graph)
 
3270
            self.target.update_revisions(self.source, stop_revision,
 
3271
                overwrite=overwrite, graph=graph)
2356
3272
            # TODO: The old revid should be specified when merging tags, 
2357
3273
            # so a tags implementation that versions tags can only 
2358
3274
            # pull in the most recent changes. -- JRV20090506
2359
 
            result.tag_updates, result.tag_conflicts = (
2360
 
                self.source.tags.merge_to(self.target.tags,
2361
 
                    "tags" in overwrite,
2362
 
                    ignore_master=not merge_tags_to_master))
 
3275
            result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
 
3276
                overwrite)
2363
3277
            result.new_revno, result.new_revid = self.target.last_revision_info()
2364
3278
            if _hook_master:
2365
3279
                result.master_branch = _hook_master
2370
3284
            if run_hooks:
2371
3285
                for hook in Branch.hooks['post_pull']:
2372
3286
                    hook(result)
 
3287
        finally:
 
3288
            self.source.unlock()
 
3289
        return result
 
3290
 
 
3291
    def push(self, overwrite=False, stop_revision=None,
 
3292
             _override_hook_source_branch=None):
 
3293
        """See InterBranch.push.
 
3294
 
 
3295
        This is the basic concrete implementation of push()
 
3296
 
 
3297
        :param _override_hook_source_branch: If specified, run
 
3298
        the hooks passing this Branch as the source, rather than self.
 
3299
        This is for use of RemoteBranch, where push is delegated to the
 
3300
        underlying vfs-based Branch.
 
3301
        """
 
3302
        # TODO: Public option to disable running hooks - should be trivial but
 
3303
        # needs tests.
 
3304
        self.source.lock_read()
 
3305
        try:
 
3306
            return _run_with_write_locked_target(
 
3307
                self.target, self._push_with_bound_branches, overwrite,
 
3308
                stop_revision,
 
3309
                _override_hook_source_branch=_override_hook_source_branch)
 
3310
        finally:
 
3311
            self.source.unlock()
 
3312
 
 
3313
    def _push_with_bound_branches(self, overwrite, stop_revision,
 
3314
            _override_hook_source_branch=None):
 
3315
        """Push from source into target, and into target's master if any.
 
3316
        """
 
3317
        def _run_hooks():
 
3318
            if _override_hook_source_branch:
 
3319
                result.source_branch = _override_hook_source_branch
 
3320
            for hook in Branch.hooks['post_push']:
 
3321
                hook(result)
 
3322
 
 
3323
        bound_location = self.target.get_bound_location()
 
3324
        if bound_location and self.target.base != bound_location:
 
3325
            # there is a master branch.
 
3326
            #
 
3327
            # XXX: Why the second check?  Is it even supported for a branch to
 
3328
            # be bound to itself? -- mbp 20070507
 
3329
            master_branch = self.target.get_master_branch()
 
3330
            master_branch.lock_write()
 
3331
            try:
 
3332
                # push into the master from the source branch.
 
3333
                self.source._basic_push(master_branch, overwrite, stop_revision)
 
3334
                # and push into the target branch from the source. Note that we
 
3335
                # push from the source branch again, because its considered the
 
3336
                # highest bandwidth repository.
 
3337
                result = self.source._basic_push(self.target, overwrite,
 
3338
                    stop_revision)
 
3339
                result.master_branch = master_branch
 
3340
                result.local_branch = self.target
 
3341
                _run_hooks()
 
3342
                return result
 
3343
            finally:
 
3344
                master_branch.unlock()
 
3345
        else:
 
3346
            # no master branch
 
3347
            result = self.source._basic_push(self.target, overwrite,
 
3348
                stop_revision)
 
3349
            # TODO: Why set master_branch and local_branch if there's no
 
3350
            # binding?  Maybe cleaner to just leave them unset? -- mbp
 
3351
            # 20070504
 
3352
            result.master_branch = self.target
 
3353
            result.local_branch = None
 
3354
            _run_hooks()
2373
3355
            return result
2374
3356
 
 
3357
    @classmethod
 
3358
    def is_compatible(self, source, target):
 
3359
        # GenericBranch uses the public API, so always compatible
 
3360
        return True
 
3361
 
 
3362
 
 
3363
class InterToBranch5(GenericInterBranch):
 
3364
 
 
3365
    @staticmethod
 
3366
    def _get_branch_formats_to_test():
 
3367
        return BranchFormat._default_format, BzrBranchFormat5()
 
3368
 
 
3369
    def pull(self, overwrite=False, stop_revision=None,
 
3370
             possible_transports=None, run_hooks=True,
 
3371
             _override_hook_target=None, local=False):
 
3372
        """Pull from source into self, updating my master if any.
 
3373
 
 
3374
        :param run_hooks: Private parameter - if false, this branch
 
3375
            is being called because it's the master of the primary branch,
 
3376
            so it should not run its hooks.
 
3377
        """
 
3378
        bound_location = self.target.get_bound_location()
 
3379
        if local and not bound_location:
 
3380
            raise errors.LocalRequiresBoundBranch()
 
3381
        master_branch = None
 
3382
        if not local and bound_location and self.source.user_url != bound_location:
 
3383
            # not pulling from master, so we need to update master.
 
3384
            master_branch = self.target.get_master_branch(possible_transports)
 
3385
            master_branch.lock_write()
 
3386
        try:
 
3387
            if master_branch:
 
3388
                # pull from source into master.
 
3389
                master_branch.pull(self.source, overwrite, stop_revision,
 
3390
                    run_hooks=False)
 
3391
            return super(InterToBranch5, self).pull(overwrite,
 
3392
                stop_revision, _hook_master=master_branch,
 
3393
                run_hooks=run_hooks,
 
3394
                _override_hook_target=_override_hook_target)
 
3395
        finally:
 
3396
            if master_branch:
 
3397
                master_branch.unlock()
 
3398
 
2375
3399
 
2376
3400
InterBranch.register_optimiser(GenericInterBranch)
 
3401
InterBranch.register_optimiser(InterToBranch5)