~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

Merge bzr.dev (and fix NEWS)

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2012 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
from __future__ import absolute_import
18
 
 
19
 
import bzrlib.bzrdir
20
 
 
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
 
18
from copy import deepcopy
21
19
from cStringIO import StringIO
22
 
 
23
 
from bzrlib.lazy_import import lazy_import
24
 
lazy_import(globals(), """
25
 
import itertools
26
 
from bzrlib import (
27
 
    bzrdir,
28
 
    controldir,
29
 
    cache_utf8,
30
 
    cleanup,
31
 
    config as _mod_config,
32
 
    debug,
33
 
    errors,
34
 
    fetch,
35
 
    graph as _mod_graph,
36
 
    lockdir,
37
 
    lockable_files,
38
 
    remote,
39
 
    repository,
40
 
    revision as _mod_revision,
41
 
    rio,
42
 
    shelf,
43
 
    tag as _mod_tag,
44
 
    transport,
45
 
    ui,
46
 
    urlutils,
47
 
    vf_search,
48
 
    )
49
 
from bzrlib.i18n import gettext, ngettext
50
 
""")
51
 
 
52
 
# Explicitly import bzrlib.bzrdir so that the BzrProber
53
 
# is guaranteed to be registered.
54
 
import bzrlib.bzrdir
55
 
 
56
 
from bzrlib import (
57
 
    bzrdir,
58
 
    controldir,
59
 
    )
60
 
from bzrlib.decorators import (
61
 
    needs_read_lock,
62
 
    needs_write_lock,
63
 
    only_raises,
64
 
    )
65
 
from bzrlib.hooks import Hooks
66
 
from bzrlib.inter import InterObject
67
 
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
68
 
from bzrlib import registry
69
 
from bzrlib.symbol_versioning import (
70
 
    deprecated_in,
71
 
    deprecated_method,
72
 
    )
73
 
from bzrlib.trace import mutter, mutter_callsite, note, is_quiet
74
 
 
75
 
 
76
 
class Branch(controldir.ControlComponent):
 
20
from unittest import TestSuite
 
21
from warnings import warn
 
22
 
 
23
import bzrlib
 
24
from bzrlib import (
 
25
        bzrdir,
 
26
        cache_utf8,
 
27
        errors,
 
28
        lockdir,
 
29
        osutils,
 
30
        revision,
 
31
        transport,
 
32
        tree,
 
33
        ui,
 
34
        urlutils,
 
35
        )
 
36
from bzrlib.config import TreeConfig
 
37
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
38
import bzrlib.errors as errors
 
39
from bzrlib.errors import (BzrError, BzrCheckError, DivergedBranches, 
 
40
                           HistoryMissing, InvalidRevisionId, 
 
41
                           InvalidRevisionNumber, LockError, NoSuchFile, 
 
42
                           NoSuchRevision, NoWorkingTree, NotVersionedError,
 
43
                           NotBranchError, UninitializableFormat, 
 
44
                           UnlistableStore, UnlistableBranch, 
 
45
                           )
 
46
from bzrlib.lockable_files import LockableFiles, TransportLock
 
47
from bzrlib.symbol_versioning import (deprecated_function,
 
48
                                      deprecated_method,
 
49
                                      DEPRECATED_PARAMETER,
 
50
                                      deprecated_passed,
 
51
                                      zero_eight, zero_nine,
 
52
                                      )
 
53
from bzrlib.trace import mutter, note
 
54
 
 
55
 
 
56
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
 
57
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
 
58
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
 
59
 
 
60
 
 
61
# TODO: Maybe include checks for common corruption of newlines, etc?
 
62
 
 
63
# TODO: Some operations like log might retrieve the same revisions
 
64
# repeatedly to calculate deltas.  We could perhaps have a weakref
 
65
# cache in memory to make this faster.  In general anything can be
 
66
# cached in memory between lock and unlock operations. .. nb thats
 
67
# what the transaction identity map provides
 
68
 
 
69
 
 
70
######################################################################
 
71
# branch objects
 
72
 
 
73
class Branch(object):
77
74
    """Branch holding a history of revisions.
78
75
 
79
 
    :ivar base:
80
 
        Base directory/url of the branch; using control_url and
81
 
        control_transport is more standardized.
82
 
    :ivar hooks: An instance of BranchHooks.
83
 
    :ivar _master_branch_cache: cached result of get_master_branch, see
84
 
        _clear_cached_state.
 
76
    base
 
77
        Base directory/url of the branch.
85
78
    """
86
79
    # this is really an instance variable - FIXME move it there
87
80
    # - RBC 20060112
88
81
    base = None
89
82
 
90
 
    @property
91
 
    def control_transport(self):
92
 
        return self._transport
93
 
 
94
 
    @property
95
 
    def user_transport(self):
96
 
        return self.bzrdir.user_transport
97
 
 
98
 
    def __init__(self, possible_transports=None):
99
 
        self.tags = self._format.make_tags(self)
100
 
        self._revision_history_cache = None
101
 
        self._revision_id_to_revno_cache = None
102
 
        self._partial_revision_id_to_revno_cache = {}
103
 
        self._partial_revision_history_cache = []
104
 
        self._tags_bytes = None
105
 
        self._last_revision_info_cache = None
106
 
        self._master_branch_cache = None
107
 
        self._merge_sorted_revisions_cache = None
108
 
        self._open_hook(possible_transports)
109
 
        hooks = Branch.hooks['open']
110
 
        for hook in hooks:
111
 
            hook(self)
112
 
 
113
 
    def _open_hook(self, possible_transports):
114
 
        """Called by init to allow simpler extension of the base class."""
115
 
 
116
 
    def _activate_fallback_location(self, url, possible_transports):
117
 
        """Activate the branch/repository from url as a fallback repository."""
118
 
        for existing_fallback_repo in self.repository._fallback_repositories:
119
 
            if existing_fallback_repo.user_url == url:
120
 
                # This fallback is already configured.  This probably only
121
 
                # happens because ControlDir.sprout is a horrible mess.  To avoid
122
 
                # confusing _unstack we don't add this a second time.
123
 
                mutter('duplicate activation of fallback %r on %r', url, self)
124
 
                return
125
 
        repo = self._get_fallback_repository(url, possible_transports)
126
 
        if repo.has_same_location(self.repository):
127
 
            raise errors.UnstackableLocationError(self.user_url, url)
128
 
        self.repository.add_fallback_repository(repo)
 
83
    def __init__(self, *ignored, **ignored_too):
 
84
        raise NotImplementedError('The Branch class is abstract')
129
85
 
130
86
    def break_lock(self):
131
87
        """Break a lock if one is present from another instance.
141
97
        if master is not None:
142
98
            master.break_lock()
143
99
 
144
 
    def _check_stackable_repo(self):
145
 
        if not self.repository._format.supports_external_lookups:
146
 
            raise errors.UnstackableRepositoryFormat(self.repository._format,
147
 
                self.repository.base)
148
 
 
149
 
    def _extend_partial_history(self, stop_index=None, stop_revision=None):
150
 
        """Extend the partial history to include a given index
151
 
 
152
 
        If a stop_index is supplied, stop when that index has been reached.
153
 
        If a stop_revision is supplied, stop when that revision is
154
 
        encountered.  Otherwise, stop when the beginning of history is
155
 
        reached.
156
 
 
157
 
        :param stop_index: The index which should be present.  When it is
158
 
            present, history extension will stop.
159
 
        :param stop_revision: The revision id which should be present.  When
160
 
            it is encountered, history extension will stop.
161
 
        """
162
 
        if len(self._partial_revision_history_cache) == 0:
163
 
            self._partial_revision_history_cache = [self.last_revision()]
164
 
        repository._iter_for_revno(
165
 
            self.repository, self._partial_revision_history_cache,
166
 
            stop_index=stop_index, stop_revision=stop_revision)
167
 
        if self._partial_revision_history_cache[-1] == _mod_revision.NULL_REVISION:
168
 
            self._partial_revision_history_cache.pop()
169
 
 
170
 
    def _get_check_refs(self):
171
 
        """Get the references needed for check().
172
 
 
173
 
        See bzrlib.check.
174
 
        """
175
 
        revid = self.last_revision()
176
 
        return [('revision-existence', revid), ('lefthand-distance', revid)]
177
 
 
178
 
    @staticmethod
179
 
    def open(base, _unsupported=False, possible_transports=None):
 
100
    @staticmethod
 
101
    @deprecated_method(zero_eight)
 
102
    def open_downlevel(base):
 
103
        """Open a branch which may be of an old format."""
 
104
        return Branch.open(base, _unsupported=True)
 
105
        
 
106
    @staticmethod
 
107
    def open(base, _unsupported=False):
180
108
        """Open the branch rooted at base.
181
109
 
182
110
        For instance, if the branch is at URL/.bzr/branch,
183
111
        Branch.open(URL) -> a Branch instance.
184
112
        """
185
 
        control = controldir.ControlDir.open(base,
186
 
            possible_transports=possible_transports, _unsupported=_unsupported)
187
 
        return control.open_branch(unsupported=_unsupported,
188
 
            possible_transports=possible_transports)
189
 
 
190
 
    @staticmethod
191
 
    def open_from_transport(transport, name=None, _unsupported=False,
192
 
            possible_transports=None):
193
 
        """Open the branch rooted at transport"""
194
 
        control = controldir.ControlDir.open_from_transport(transport, _unsupported)
195
 
        return control.open_branch(name=name, unsupported=_unsupported,
196
 
            possible_transports=possible_transports)
197
 
 
198
 
    @staticmethod
199
 
    def open_containing(url, possible_transports=None):
 
113
        control = bzrdir.BzrDir.open(base, _unsupported)
 
114
        return control.open_branch(_unsupported)
 
115
 
 
116
    @staticmethod
 
117
    def open_containing(url):
200
118
        """Open an existing branch which contains url.
201
 
 
 
119
        
202
120
        This probes for a branch at url, and searches upwards from there.
203
121
 
204
122
        Basically we keep looking up until we find the control directory or
205
123
        run into the root.  If there isn't one, raises NotBranchError.
206
 
        If there is one and it is either an unrecognised format or an unsupported
 
124
        If there is one and it is either an unrecognised format or an unsupported 
207
125
        format, UnknownFormatError or UnsupportedFormatError are raised.
208
126
        If there is one, it is returned, along with the unused portion of url.
209
127
        """
210
 
        control, relpath = controldir.ControlDir.open_containing(url,
211
 
                                                         possible_transports)
212
 
        branch = control.open_branch(possible_transports=possible_transports)
213
 
        return (branch, relpath)
214
 
 
215
 
    def _push_should_merge_tags(self):
216
 
        """Should _basic_push merge this branch's tags into the target?
217
 
 
218
 
        The default implementation returns False if this branch has no tags,
219
 
        and True the rest of the time.  Subclasses may override this.
220
 
        """
221
 
        return self.supports_tags() and self.tags.get_tag_dict()
 
128
        control, relpath = bzrdir.BzrDir.open_containing(url)
 
129
        return control.open_branch(), relpath
 
130
 
 
131
    @staticmethod
 
132
    @deprecated_function(zero_eight)
 
133
    def initialize(base):
 
134
        """Create a new working tree and branch, rooted at 'base' (url)
 
135
 
 
136
        NOTE: This will soon be deprecated in favour of creation
 
137
        through a BzrDir.
 
138
        """
 
139
        return bzrdir.BzrDir.create_standalone_workingtree(base).branch
 
140
 
 
141
    def setup_caching(self, cache_root):
 
142
        """Subclasses that care about caching should override this, and set
 
143
        up cached stores located under cache_root.
 
144
        """
 
145
        # seems to be unused, 2006-01-13 mbp
 
146
        warn('%s is deprecated' % self.setup_caching)
 
147
        self.cache_root = cache_root
222
148
 
223
149
    def get_config(self):
224
 
        """Get a bzrlib.config.BranchConfig for this Branch.
225
 
 
226
 
        This can then be used to get and set configuration options for the
227
 
        branch.
228
 
 
229
 
        :return: A bzrlib.config.BranchConfig.
230
 
        """
231
 
        return _mod_config.BranchConfig(self)
232
 
 
233
 
    def get_config_stack(self):
234
 
        """Get a bzrlib.config.BranchStack for this Branch.
235
 
 
236
 
        This can then be used to get and set configuration options for the
237
 
        branch.
238
 
 
239
 
        :return: A bzrlib.config.BranchStack.
240
 
        """
241
 
        return _mod_config.BranchStack(self)
242
 
 
243
 
    def _get_config(self):
244
 
        """Get the concrete config for just the config in this branch.
245
 
 
246
 
        This is not intended for client use; see Branch.get_config for the
247
 
        public API.
248
 
 
249
 
        Added in 1.14.
250
 
 
251
 
        :return: An object supporting get_option and set_option.
252
 
        """
253
 
        raise NotImplementedError(self._get_config)
254
 
 
255
 
    def store_uncommitted(self, creator):
256
 
        """Store uncommitted changes from a ShelfCreator.
257
 
 
258
 
        :param creator: The ShelfCreator containing uncommitted changes, or
259
 
            None to delete any stored changes.
260
 
        :raises: ChangesAlreadyStored if the branch already has changes.
261
 
        """
262
 
        raise NotImplementedError(self.store_uncommitted)
263
 
 
264
 
    def get_unshelver(self, tree):
265
 
        """Return a shelf.Unshelver for this branch and tree.
266
 
 
267
 
        :param tree: The tree to use to construct the Unshelver.
268
 
        :return: an Unshelver or None if no changes are stored.
269
 
        """
270
 
        raise NotImplementedError(self.get_unshelver)
271
 
 
272
 
    def _get_fallback_repository(self, url, possible_transports):
273
 
        """Get the repository we fallback to at url."""
274
 
        url = urlutils.join(self.base, url)
275
 
        a_branch = Branch.open(url, possible_transports=possible_transports)
276
 
        return a_branch.repository
277
 
 
278
 
    @needs_read_lock
279
 
    def _get_tags_bytes(self):
280
 
        """Get the bytes of a serialised tags dict.
281
 
 
282
 
        Note that not all branches support tags, nor do all use the same tags
283
 
        logic: this method is specific to BasicTags. Other tag implementations
284
 
        may use the same method name and behave differently, safely, because
285
 
        of the double-dispatch via
286
 
        format.make_tags->tags_instance->get_tags_dict.
287
 
 
288
 
        :return: The bytes of the tags file.
289
 
        :seealso: Branch._set_tags_bytes.
290
 
        """
291
 
        if self._tags_bytes is None:
292
 
            self._tags_bytes = self._transport.get_bytes('tags')
293
 
        return self._tags_bytes
294
 
 
295
 
    def _get_nick(self, local=False, possible_transports=None):
296
 
        config = self.get_config()
297
 
        # explicit overrides master, but don't look for master if local is True
298
 
        if not local and not config.has_explicit_nickname():
299
 
            try:
300
 
                master = self.get_master_branch(possible_transports)
301
 
                if master and self.user_url == master.user_url:
302
 
                    raise errors.RecursiveBind(self.user_url)
303
 
                if master is not None:
304
 
                    # return the master branch value
305
 
                    return master.nick
306
 
            except errors.RecursiveBind, e:
307
 
                raise e
308
 
            except errors.BzrError, e:
309
 
                # Silently fall back to local implicit nick if the master is
310
 
                # unavailable
311
 
                mutter("Could not connect to bound branch, "
312
 
                    "falling back to local nick.\n " + str(e))
313
 
        return config.get_nickname()
 
150
        return bzrlib.config.BranchConfig(self)
 
151
 
 
152
    def _get_nick(self):
 
153
        return self.get_config().get_nickname()
314
154
 
315
155
    def _set_nick(self, nick):
316
 
        self.get_config().set_user_option('nickname', nick, warn_masked=True)
 
156
        self.get_config().set_user_option('nickname', nick)
317
157
 
318
158
    nick = property(_get_nick, _set_nick)
319
159
 
320
160
    def is_locked(self):
321
161
        raise NotImplementedError(self.is_locked)
322
162
 
323
 
    def _lefthand_history(self, revision_id, last_rev=None,
324
 
                          other_branch=None):
325
 
        if 'evil' in debug.debug_flags:
326
 
            mutter_callsite(4, "_lefthand_history scales with history.")
327
 
        # stop_revision must be a descendant of last_revision
328
 
        graph = self.repository.get_graph()
329
 
        if last_rev is not None:
330
 
            if not graph.is_ancestor(last_rev, revision_id):
331
 
                # our previous tip is not merged into stop_revision
332
 
                raise errors.DivergedBranches(self, other_branch)
333
 
        # make a new revision history from the graph
334
 
        parents_map = graph.get_parent_map([revision_id])
335
 
        if revision_id not in parents_map:
336
 
            raise errors.NoSuchRevision(self, revision_id)
337
 
        current_rev_id = revision_id
338
 
        new_history = []
339
 
        check_not_reserved_id = _mod_revision.check_not_reserved_id
340
 
        # Do not include ghosts or graph origin in revision_history
341
 
        while (current_rev_id in parents_map and
342
 
               len(parents_map[current_rev_id]) > 0):
343
 
            check_not_reserved_id(current_rev_id)
344
 
            new_history.append(current_rev_id)
345
 
            current_rev_id = parents_map[current_rev_id][0]
346
 
            parents_map = graph.get_parent_map([current_rev_id])
347
 
        new_history.reverse()
348
 
        return new_history
349
 
 
350
 
    def lock_write(self, token=None):
351
 
        """Lock the branch for write operations.
352
 
 
353
 
        :param token: A token to permit reacquiring a previously held and
354
 
            preserved lock.
355
 
        :return: A BranchWriteLockResult.
356
 
        """
 
163
    def lock_write(self):
357
164
        raise NotImplementedError(self.lock_write)
358
165
 
359
166
    def lock_read(self):
360
 
        """Lock the branch for read operations.
361
 
 
362
 
        :return: A bzrlib.lock.LogicalLockResult.
363
 
        """
364
167
        raise NotImplementedError(self.lock_read)
365
168
 
366
169
    def unlock(self):
373
176
    def get_physical_lock_status(self):
374
177
        raise NotImplementedError(self.get_physical_lock_status)
375
178
 
376
 
    @needs_read_lock
377
 
    def dotted_revno_to_revision_id(self, revno, _cache_reverse=False):
378
 
        """Return the revision_id for a dotted revno.
379
 
 
380
 
        :param revno: a tuple like (1,) or (1,1,2)
381
 
        :param _cache_reverse: a private parameter enabling storage
382
 
           of the reverse mapping in a top level cache. (This should
383
 
           only be done in selective circumstances as we want to
384
 
           avoid having the mapping cached multiple times.)
385
 
        :return: the revision_id
386
 
        :raises errors.NoSuchRevision: if the revno doesn't exist
387
 
        """
388
 
        rev_id = self._do_dotted_revno_to_revision_id(revno)
389
 
        if _cache_reverse:
390
 
            self._partial_revision_id_to_revno_cache[rev_id] = revno
391
 
        return rev_id
392
 
 
393
 
    def _do_dotted_revno_to_revision_id(self, revno):
394
 
        """Worker function for dotted_revno_to_revision_id.
395
 
 
396
 
        Subclasses should override this if they wish to
397
 
        provide a more efficient implementation.
398
 
        """
399
 
        if len(revno) == 1:
400
 
            return self.get_rev_id(revno[0])
401
 
        revision_id_to_revno = self.get_revision_id_to_revno_map()
402
 
        revision_ids = [revision_id for revision_id, this_revno
403
 
                        in revision_id_to_revno.iteritems()
404
 
                        if revno == this_revno]
405
 
        if len(revision_ids) == 1:
406
 
            return revision_ids[0]
407
 
        else:
408
 
            revno_str = '.'.join(map(str, revno))
409
 
            raise errors.NoSuchRevision(self, revno_str)
410
 
 
411
 
    @needs_read_lock
412
 
    def revision_id_to_dotted_revno(self, revision_id):
413
 
        """Given a revision id, return its dotted revno.
414
 
 
415
 
        :return: a tuple like (1,) or (400,1,3).
416
 
        """
417
 
        return self._do_revision_id_to_dotted_revno(revision_id)
418
 
 
419
 
    def _do_revision_id_to_dotted_revno(self, revision_id):
420
 
        """Worker function for revision_id_to_revno."""
421
 
        # Try the caches if they are loaded
422
 
        result = self._partial_revision_id_to_revno_cache.get(revision_id)
423
 
        if result is not None:
424
 
            return result
425
 
        if self._revision_id_to_revno_cache:
426
 
            result = self._revision_id_to_revno_cache.get(revision_id)
427
 
            if result is None:
428
 
                raise errors.NoSuchRevision(self, revision_id)
429
 
        # Try the mainline as it's optimised
430
 
        try:
431
 
            revno = self.revision_id_to_revno(revision_id)
432
 
            return (revno,)
433
 
        except errors.NoSuchRevision:
434
 
            # We need to load and use the full revno map after all
435
 
            result = self.get_revision_id_to_revno_map().get(revision_id)
436
 
            if result is None:
437
 
                raise errors.NoSuchRevision(self, revision_id)
438
 
        return result
439
 
 
440
 
    @needs_read_lock
441
 
    def get_revision_id_to_revno_map(self):
442
 
        """Return the revision_id => dotted revno map.
443
 
 
444
 
        This will be regenerated on demand, but will be cached.
445
 
 
446
 
        :return: A dictionary mapping revision_id => dotted revno.
447
 
            This dictionary should not be modified by the caller.
448
 
        """
449
 
        if self._revision_id_to_revno_cache is not None:
450
 
            mapping = self._revision_id_to_revno_cache
451
 
        else:
452
 
            mapping = self._gen_revno_map()
453
 
            self._cache_revision_id_to_revno(mapping)
454
 
        # TODO: jam 20070417 Since this is being cached, should we be returning
455
 
        #       a copy?
456
 
        # I would rather not, and instead just declare that users should not
457
 
        # modify the return value.
458
 
        return mapping
459
 
 
460
 
    def _gen_revno_map(self):
461
 
        """Create a new mapping from revision ids to dotted revnos.
462
 
 
463
 
        Dotted revnos are generated based on the current tip in the revision
464
 
        history.
465
 
        This is the worker function for get_revision_id_to_revno_map, which
466
 
        just caches the return value.
467
 
 
468
 
        :return: A dictionary mapping revision_id => dotted revno.
469
 
        """
470
 
        revision_id_to_revno = dict((rev_id, revno)
471
 
            for rev_id, depth, revno, end_of_merge
472
 
             in self.iter_merge_sorted_revisions())
473
 
        return revision_id_to_revno
474
 
 
475
 
    @needs_read_lock
476
 
    def iter_merge_sorted_revisions(self, start_revision_id=None,
477
 
            stop_revision_id=None, stop_rule='exclude', direction='reverse'):
478
 
        """Walk the revisions for a branch in merge sorted order.
479
 
 
480
 
        Merge sorted order is the output from a merge-aware,
481
 
        topological sort, i.e. all parents come before their
482
 
        children going forward; the opposite for reverse.
483
 
 
484
 
        :param start_revision_id: the revision_id to begin walking from.
485
 
            If None, the branch tip is used.
486
 
        :param stop_revision_id: the revision_id to terminate the walk
487
 
            after. If None, the rest of history is included.
488
 
        :param stop_rule: if stop_revision_id is not None, the precise rule
489
 
            to use for termination:
490
 
 
491
 
            * 'exclude' - leave the stop revision out of the result (default)
492
 
            * 'include' - the stop revision is the last item in the result
493
 
            * 'with-merges' - include the stop revision and all of its
494
 
              merged revisions in the result
495
 
            * 'with-merges-without-common-ancestry' - filter out revisions 
496
 
              that are in both ancestries
497
 
        :param direction: either 'reverse' or 'forward':
498
 
 
499
 
            * reverse means return the start_revision_id first, i.e.
500
 
              start at the most recent revision and go backwards in history
501
 
            * forward returns tuples in the opposite order to reverse.
502
 
              Note in particular that forward does *not* do any intelligent
503
 
              ordering w.r.t. depth as some clients of this API may like.
504
 
              (If required, that ought to be done at higher layers.)
505
 
 
506
 
        :return: an iterator over (revision_id, depth, revno, end_of_merge)
507
 
            tuples where:
508
 
 
509
 
            * revision_id: the unique id of the revision
510
 
            * depth: How many levels of merging deep this node has been
511
 
              found.
512
 
            * revno_sequence: This field provides a sequence of
513
 
              revision numbers for all revisions. The format is:
514
 
              (REVNO, BRANCHNUM, BRANCHREVNO). BRANCHNUM is the number of the
515
 
              branch that the revno is on. From left to right the REVNO numbers
516
 
              are the sequence numbers within that branch of the revision.
517
 
            * end_of_merge: When True the next node (earlier in history) is
518
 
              part of a different merge.
519
 
        """
520
 
        # Note: depth and revno values are in the context of the branch so
521
 
        # we need the full graph to get stable numbers, regardless of the
522
 
        # start_revision_id.
523
 
        if self._merge_sorted_revisions_cache is None:
524
 
            last_revision = self.last_revision()
525
 
            known_graph = self.repository.get_known_graph_ancestry(
526
 
                [last_revision])
527
 
            self._merge_sorted_revisions_cache = known_graph.merge_sort(
528
 
                last_revision)
529
 
        filtered = self._filter_merge_sorted_revisions(
530
 
            self._merge_sorted_revisions_cache, start_revision_id,
531
 
            stop_revision_id, stop_rule)
532
 
        # Make sure we don't return revisions that are not part of the
533
 
        # start_revision_id ancestry.
534
 
        filtered = self._filter_start_non_ancestors(filtered)
535
 
        if direction == 'reverse':
536
 
            return filtered
537
 
        if direction == 'forward':
538
 
            return reversed(list(filtered))
539
 
        else:
540
 
            raise ValueError('invalid direction %r' % direction)
541
 
 
542
 
    def _filter_merge_sorted_revisions(self, merge_sorted_revisions,
543
 
        start_revision_id, stop_revision_id, stop_rule):
544
 
        """Iterate over an inclusive range of sorted revisions."""
545
 
        rev_iter = iter(merge_sorted_revisions)
546
 
        if start_revision_id is not None:
547
 
            for node in rev_iter:
548
 
                rev_id = node.key
549
 
                if rev_id != start_revision_id:
550
 
                    continue
551
 
                else:
552
 
                    # The decision to include the start or not
553
 
                    # depends on the stop_rule if a stop is provided
554
 
                    # so pop this node back into the iterator
555
 
                    rev_iter = itertools.chain(iter([node]), rev_iter)
556
 
                    break
557
 
        if stop_revision_id is None:
558
 
            # Yield everything
559
 
            for node in rev_iter:
560
 
                rev_id = node.key
561
 
                yield (rev_id, node.merge_depth, node.revno,
562
 
                       node.end_of_merge)
563
 
        elif stop_rule == 'exclude':
564
 
            for node in rev_iter:
565
 
                rev_id = node.key
566
 
                if rev_id == stop_revision_id:
567
 
                    return
568
 
                yield (rev_id, node.merge_depth, node.revno,
569
 
                       node.end_of_merge)
570
 
        elif stop_rule == 'include':
571
 
            for node in rev_iter:
572
 
                rev_id = node.key
573
 
                yield (rev_id, node.merge_depth, node.revno,
574
 
                       node.end_of_merge)
575
 
                if rev_id == stop_revision_id:
576
 
                    return
577
 
        elif stop_rule == 'with-merges-without-common-ancestry':
578
 
            # We want to exclude all revisions that are already part of the
579
 
            # stop_revision_id ancestry.
580
 
            graph = self.repository.get_graph()
581
 
            ancestors = graph.find_unique_ancestors(start_revision_id,
582
 
                                                    [stop_revision_id])
583
 
            for node in rev_iter:
584
 
                rev_id = node.key
585
 
                if rev_id not in ancestors:
586
 
                    continue
587
 
                yield (rev_id, node.merge_depth, node.revno,
588
 
                       node.end_of_merge)
589
 
        elif stop_rule == 'with-merges':
590
 
            stop_rev = self.repository.get_revision(stop_revision_id)
591
 
            if stop_rev.parent_ids:
592
 
                left_parent = stop_rev.parent_ids[0]
593
 
            else:
594
 
                left_parent = _mod_revision.NULL_REVISION
595
 
            # left_parent is the actual revision we want to stop logging at,
596
 
            # since we want to show the merged revisions after the stop_rev too
597
 
            reached_stop_revision_id = False
598
 
            revision_id_whitelist = []
599
 
            for node in rev_iter:
600
 
                rev_id = node.key
601
 
                if rev_id == left_parent:
602
 
                    # reached the left parent after the stop_revision
603
 
                    return
604
 
                if (not reached_stop_revision_id or
605
 
                        rev_id in revision_id_whitelist):
606
 
                    yield (rev_id, node.merge_depth, node.revno,
607
 
                       node.end_of_merge)
608
 
                    if reached_stop_revision_id or rev_id == stop_revision_id:
609
 
                        # only do the merged revs of rev_id from now on
610
 
                        rev = self.repository.get_revision(rev_id)
611
 
                        if rev.parent_ids:
612
 
                            reached_stop_revision_id = True
613
 
                            revision_id_whitelist.extend(rev.parent_ids)
614
 
        else:
615
 
            raise ValueError('invalid stop_rule %r' % stop_rule)
616
 
 
617
 
    def _filter_start_non_ancestors(self, rev_iter):
618
 
        # If we started from a dotted revno, we want to consider it as a tip
619
 
        # and don't want to yield revisions that are not part of its
620
 
        # ancestry. Given the order guaranteed by the merge sort, we will see
621
 
        # uninteresting descendants of the first parent of our tip before the
622
 
        # tip itself.
623
 
        first = rev_iter.next()
624
 
        (rev_id, merge_depth, revno, end_of_merge) = first
625
 
        yield first
626
 
        if not merge_depth:
627
 
            # We start at a mainline revision so by definition, all others
628
 
            # revisions in rev_iter are ancestors
629
 
            for node in rev_iter:
630
 
                yield node
631
 
 
632
 
        clean = False
633
 
        whitelist = set()
634
 
        pmap = self.repository.get_parent_map([rev_id])
635
 
        parents = pmap.get(rev_id, [])
636
 
        if parents:
637
 
            whitelist.update(parents)
638
 
        else:
639
 
            # If there is no parents, there is nothing of interest left
640
 
 
641
 
            # FIXME: It's hard to test this scenario here as this code is never
642
 
            # called in that case. -- vila 20100322
643
 
            return
644
 
 
645
 
        for (rev_id, merge_depth, revno, end_of_merge) in rev_iter:
646
 
            if not clean:
647
 
                if rev_id in whitelist:
648
 
                    pmap = self.repository.get_parent_map([rev_id])
649
 
                    parents = pmap.get(rev_id, [])
650
 
                    whitelist.remove(rev_id)
651
 
                    whitelist.update(parents)
652
 
                    if merge_depth == 0:
653
 
                        # We've reached the mainline, there is nothing left to
654
 
                        # filter
655
 
                        clean = True
656
 
                else:
657
 
                    # A revision that is not part of the ancestry of our
658
 
                    # starting revision.
659
 
                    continue
660
 
            yield (rev_id, merge_depth, revno, end_of_merge)
661
 
 
662
 
    def leave_lock_in_place(self):
663
 
        """Tell this branch object not to release the physical lock when this
664
 
        object is unlocked.
665
 
 
666
 
        If lock_write doesn't return a token, then this method is not supported.
667
 
        """
668
 
        self.control_files.leave_in_place()
669
 
 
670
 
    def dont_leave_lock_in_place(self):
671
 
        """Tell this branch object to release the physical lock when this
672
 
        object is unlocked, even if it didn't originally acquire it.
673
 
 
674
 
        If lock_write doesn't return a token, then this method is not supported.
675
 
        """
676
 
        self.control_files.dont_leave_in_place()
 
179
    def abspath(self, name):
 
180
        """Return absolute filename for something in the branch
 
181
        
 
182
        XXX: Robert Collins 20051017 what is this used for? why is it a branch
 
183
        method and not a tree method.
 
184
        """
 
185
        raise NotImplementedError(self.abspath)
677
186
 
678
187
    def bind(self, other):
679
188
        """Bind the local branch the other branch.
681
190
        :param other: The branch to bind to
682
191
        :type other: Branch
683
192
        """
684
 
        raise errors.UpgradeRequired(self.user_url)
685
 
 
686
 
    def get_append_revisions_only(self):
687
 
        """Whether it is only possible to append revisions to the history.
688
 
        """
689
 
        if not self._format.supports_set_append_revisions_only():
690
 
            return False
691
 
        return self.get_config_stack().get('append_revisions_only')
692
 
 
693
 
    def set_append_revisions_only(self, enabled):
694
 
        if not self._format.supports_set_append_revisions_only():
695
 
            raise errors.UpgradeRequired(self.user_url)
696
 
        self.get_config_stack().set('append_revisions_only', enabled)
697
 
 
698
 
    def set_reference_info(self, file_id, tree_path, branch_location):
699
 
        """Set the branch location to use for a tree reference."""
700
 
        raise errors.UnsupportedOperation(self.set_reference_info, self)
701
 
 
702
 
    def get_reference_info(self, file_id):
703
 
        """Get the tree_path and branch_location for a tree reference."""
704
 
        raise errors.UnsupportedOperation(self.get_reference_info, self)
 
193
        raise errors.UpgradeRequired(self.base)
705
194
 
706
195
    @needs_write_lock
707
 
    def fetch(self, from_branch, last_revision=None, limit=None):
 
196
    def fetch(self, from_branch, last_revision=None, pb=None):
708
197
        """Copy revisions from from_branch into this branch.
709
198
 
710
199
        :param from_branch: Where to copy from.
711
200
        :param last_revision: What revision to stop at (None for at the end
712
201
                              of the branch.
713
 
        :param limit: Optional rough limit of revisions to fetch
714
 
        :return: None
 
202
        :param pb: An optional progress bar to use.
 
203
 
 
204
        Returns the copied revision count and the failed revisions in a tuple:
 
205
        (copied, failures).
715
206
        """
716
 
        return InterBranch.get(from_branch, self).fetch(last_revision, limit=limit)
 
207
        if self.base == from_branch.base:
 
208
            return (0, [])
 
209
        if pb is None:
 
210
            nested_pb = ui.ui_factory.nested_progress_bar()
 
211
            pb = nested_pb
 
212
        else:
 
213
            nested_pb = None
 
214
 
 
215
        from_branch.lock_read()
 
216
        try:
 
217
            if last_revision is None:
 
218
                pb.update('get source history')
 
219
                from_history = from_branch.revision_history()
 
220
                if from_history:
 
221
                    last_revision = from_history[-1]
 
222
                else:
 
223
                    # no history in the source branch
 
224
                    last_revision = revision.NULL_REVISION
 
225
            return self.repository.fetch(from_branch.repository,
 
226
                                         revision_id=last_revision,
 
227
                                         pb=nested_pb)
 
228
        finally:
 
229
            if nested_pb is not None:
 
230
                nested_pb.finished()
 
231
            from_branch.unlock()
717
232
 
718
233
    def get_bound_location(self):
719
234
        """Return the URL of the branch we are bound to.
722
237
        branch.
723
238
        """
724
239
        return None
725
 
 
726
 
    def get_old_bound_location(self):
727
 
        """Return the URL of the branch we used to be bound to
728
 
        """
729
 
        raise errors.UpgradeRequired(self.user_url)
730
 
 
731
 
    def get_commit_builder(self, parents, config_stack=None, timestamp=None,
732
 
                           timezone=None, committer=None, revprops=None,
733
 
                           revision_id=None, lossy=False):
 
240
    
 
241
    def get_commit_builder(self, parents, config=None, timestamp=None, 
 
242
                           timezone=None, committer=None, revprops=None, 
 
243
                           revision_id=None):
734
244
        """Obtain a CommitBuilder for this branch.
735
 
 
 
245
        
736
246
        :param parents: Revision ids of the parents of the new revision.
737
247
        :param config: Optional configuration to use.
738
248
        :param timestamp: Optional timestamp recorded for commit.
740
250
        :param committer: Optional committer to set for commit.
741
251
        :param revprops: Optional dictionary of revision properties.
742
252
        :param revision_id: Optional revision id.
743
 
        :param lossy: Whether to discard data that can not be natively
744
 
            represented, when pushing to a foreign VCS 
745
253
        """
746
254
 
747
 
        if config_stack is None:
748
 
            config_stack = self.get_config_stack()
749
 
 
750
 
        return self.repository.get_commit_builder(self, parents, config_stack,
751
 
            timestamp, timezone, committer, revprops, revision_id,
752
 
            lossy)
753
 
 
754
 
    def get_master_branch(self, possible_transports=None):
 
255
        if config is None:
 
256
            config = self.get_config()
 
257
        
 
258
        return self.repository.get_commit_builder(self, parents, config, 
 
259
            timestamp, timezone, committer, revprops, revision_id)
 
260
 
 
261
    def get_master_branch(self):
755
262
        """Return the branch we are bound to.
756
 
 
 
263
        
757
264
        :return: Either a Branch, or None
758
265
        """
759
266
        return None
760
267
 
761
 
    @deprecated_method(deprecated_in((2, 5, 0)))
762
268
    def get_revision_delta(self, revno):
763
269
        """Return the delta for one revision.
764
270
 
765
271
        The delta is relative to its mainline predecessor, or the
766
272
        empty tree for revision 1.
767
273
        """
768
 
        try:
769
 
            revid = self.get_rev_id(revno)
770
 
        except errors.NoSuchRevision:
771
 
            raise errors.InvalidRevisionNumber(revno)
772
 
        return self.repository.get_revision_delta(revid)
773
 
 
774
 
    def get_stacked_on_url(self):
775
 
        """Get the URL this branch is stacked against.
776
 
 
777
 
        :raises NotStacked: If the branch is not stacked.
778
 
        :raises UnstackableBranchFormat: If the branch does not support
779
 
            stacking.
780
 
        """
781
 
        raise NotImplementedError(self.get_stacked_on_url)
 
274
        assert isinstance(revno, int)
 
275
        rh = self.revision_history()
 
276
        if not (1 <= revno <= len(rh)):
 
277
            raise InvalidRevisionNumber(revno)
 
278
        return self.repository.get_revision_delta(rh[revno-1])
 
279
 
 
280
    def get_root_id(self):
 
281
        """Return the id of this branches root"""
 
282
        raise NotImplementedError(self.get_root_id)
782
283
 
783
284
    def print_file(self, file, revision_id):
784
285
        """Print `file` to stdout."""
785
286
        raise NotImplementedError(self.print_file)
786
287
 
787
 
    @needs_write_lock
788
 
    def set_last_revision_info(self, revno, revision_id):
789
 
        """Set the last revision of this branch.
790
 
 
791
 
        The caller is responsible for checking that the revno is correct
792
 
        for this revision id.
793
 
 
794
 
        It may be possible to set the branch last revision to an id not
795
 
        present in the repository.  However, branches can also be
796
 
        configured to check constraints on history, in which case this may not
797
 
        be permitted.
798
 
        """
799
 
        raise NotImplementedError(self.set_last_revision_info)
800
 
 
801
 
    @needs_write_lock
802
 
    def generate_revision_history(self, revision_id, last_rev=None,
803
 
                                  other_branch=None):
804
 
        """See Branch.generate_revision_history"""
805
 
        graph = self.repository.get_graph()
806
 
        (last_revno, last_revid) = self.last_revision_info()
807
 
        known_revision_ids = [
808
 
            (last_revid, last_revno),
809
 
            (_mod_revision.NULL_REVISION, 0),
810
 
            ]
811
 
        if last_rev is not None:
812
 
            if not graph.is_ancestor(last_rev, revision_id):
813
 
                # our previous tip is not merged into stop_revision
814
 
                raise errors.DivergedBranches(self, other_branch)
815
 
        revno = graph.find_distance_to_null(revision_id, known_revision_ids)
816
 
        self.set_last_revision_info(revno, revision_id)
817
 
 
818
 
    @needs_write_lock
819
 
    def set_parent(self, url):
820
 
        """See Branch.set_parent."""
821
 
        # TODO: Maybe delete old location files?
822
 
        # URLs should never be unicode, even on the local fs,
823
 
        # FIXUP this and get_parent in a future branch format bump:
824
 
        # read and rewrite the file. RBC 20060125
825
 
        if url is not None:
826
 
            if isinstance(url, unicode):
827
 
                try:
828
 
                    url = url.encode('ascii')
829
 
                except UnicodeEncodeError:
830
 
                    raise errors.InvalidURL(url,
831
 
                        "Urls must be 7-bit ascii, "
832
 
                        "use bzrlib.urlutils.escape")
833
 
            url = urlutils.relative_url(self.base, url)
834
 
        self._set_parent_location(url)
835
 
 
836
 
    @needs_write_lock
837
 
    def set_stacked_on_url(self, url):
838
 
        """Set the URL this branch is stacked against.
839
 
 
840
 
        :raises UnstackableBranchFormat: If the branch does not support
841
 
            stacking.
842
 
        :raises UnstackableRepositoryFormat: If the repository does not support
843
 
            stacking.
844
 
        """
845
 
        if not self._format.supports_stacking():
846
 
            raise errors.UnstackableBranchFormat(self._format, self.user_url)
847
 
        # XXX: Changing from one fallback repository to another does not check
848
 
        # that all the data you need is present in the new fallback.
849
 
        # Possibly it should.
850
 
        self._check_stackable_repo()
851
 
        if not url:
852
 
            try:
853
 
                old_url = self.get_stacked_on_url()
854
 
            except (errors.NotStacked, errors.UnstackableBranchFormat,
855
 
                errors.UnstackableRepositoryFormat):
856
 
                return
857
 
            self._unstack()
858
 
        else:
859
 
            self._activate_fallback_location(url,
860
 
                possible_transports=[self.bzrdir.root_transport])
861
 
        # write this out after the repository is stacked to avoid setting a
862
 
        # stacked config that doesn't work.
863
 
        self._set_config_location('stacked_on_location', url)
864
 
 
865
 
    def _unstack(self):
866
 
        """Change a branch to be unstacked, copying data as needed.
867
 
 
868
 
        Don't call this directly, use set_stacked_on_url(None).
869
 
        """
870
 
        pb = ui.ui_factory.nested_progress_bar()
871
 
        try:
872
 
            pb.update(gettext("Unstacking"))
873
 
            # The basic approach here is to fetch the tip of the branch,
874
 
            # including all available ghosts, from the existing stacked
875
 
            # repository into a new repository object without the fallbacks. 
876
 
            #
877
 
            # XXX: See <https://launchpad.net/bugs/397286> - this may not be
878
 
            # correct for CHKMap repostiories
879
 
            old_repository = self.repository
880
 
            if len(old_repository._fallback_repositories) != 1:
881
 
                raise AssertionError("can't cope with fallback repositories "
882
 
                    "of %r (fallbacks: %r)" % (old_repository,
883
 
                        old_repository._fallback_repositories))
884
 
            # Open the new repository object.
885
 
            # Repositories don't offer an interface to remove fallback
886
 
            # repositories today; take the conceptually simpler option and just
887
 
            # reopen it.  We reopen it starting from the URL so that we
888
 
            # get a separate connection for RemoteRepositories and can
889
 
            # stream from one of them to the other.  This does mean doing
890
 
            # separate SSH connection setup, but unstacking is not a
891
 
            # common operation so it's tolerable.
892
 
            new_bzrdir = controldir.ControlDir.open(
893
 
                self.bzrdir.root_transport.base)
894
 
            new_repository = new_bzrdir.find_repository()
895
 
            if new_repository._fallback_repositories:
896
 
                raise AssertionError("didn't expect %r to have "
897
 
                    "fallback_repositories"
898
 
                    % (self.repository,))
899
 
            # Replace self.repository with the new repository.
900
 
            # Do our best to transfer the lock state (i.e. lock-tokens and
901
 
            # lock count) of self.repository to the new repository.
902
 
            lock_token = old_repository.lock_write().repository_token
903
 
            self.repository = new_repository
904
 
            if isinstance(self, remote.RemoteBranch):
905
 
                # Remote branches can have a second reference to the old
906
 
                # repository that need to be replaced.
907
 
                if self._real_branch is not None:
908
 
                    self._real_branch.repository = new_repository
909
 
            self.repository.lock_write(token=lock_token)
910
 
            if lock_token is not None:
911
 
                old_repository.leave_lock_in_place()
912
 
            old_repository.unlock()
913
 
            if lock_token is not None:
914
 
                # XXX: self.repository.leave_lock_in_place() before this
915
 
                # function will not be preserved.  Fortunately that doesn't
916
 
                # affect the current default format (2a), and would be a
917
 
                # corner-case anyway.
918
 
                #  - Andrew Bennetts, 2010/06/30
919
 
                self.repository.dont_leave_lock_in_place()
920
 
            old_lock_count = 0
921
 
            while True:
922
 
                try:
923
 
                    old_repository.unlock()
924
 
                except errors.LockNotHeld:
925
 
                    break
926
 
                old_lock_count += 1
927
 
            if old_lock_count == 0:
928
 
                raise AssertionError(
929
 
                    'old_repository should have been locked at least once.')
930
 
            for i in range(old_lock_count-1):
931
 
                self.repository.lock_write()
932
 
            # Fetch from the old repository into the new.
933
 
            old_repository.lock_read()
934
 
            try:
935
 
                # XXX: If you unstack a branch while it has a working tree
936
 
                # with a pending merge, the pending-merged revisions will no
937
 
                # longer be present.  You can (probably) revert and remerge.
938
 
                try:
939
 
                    tags_to_fetch = set(self.tags.get_reverse_tag_dict())
940
 
                except errors.TagsNotSupported:
941
 
                    tags_to_fetch = set()
942
 
                fetch_spec = vf_search.NotInOtherForRevs(self.repository,
943
 
                    old_repository, required_ids=[self.last_revision()],
944
 
                    if_present_ids=tags_to_fetch, find_ghosts=True).execute()
945
 
                self.repository.fetch(old_repository, fetch_spec=fetch_spec)
946
 
            finally:
947
 
                old_repository.unlock()
948
 
        finally:
949
 
            pb.finished()
950
 
 
951
 
    def _set_tags_bytes(self, bytes):
952
 
        """Mirror method for _get_tags_bytes.
953
 
 
954
 
        :seealso: Branch._get_tags_bytes.
955
 
        """
956
 
        op = cleanup.OperationWithCleanups(self._set_tags_bytes_locked)
957
 
        op.add_cleanup(self.lock_write().unlock)
958
 
        return op.run_simple(bytes)
959
 
 
960
 
    def _set_tags_bytes_locked(self, bytes):
961
 
        self._tags_bytes = bytes
962
 
        return self._transport.put_bytes('tags', bytes)
963
 
 
964
 
    def _cache_revision_history(self, rev_history):
965
 
        """Set the cached revision history to rev_history.
966
 
 
967
 
        The revision_history method will use this cache to avoid regenerating
968
 
        the revision history.
969
 
 
970
 
        This API is semi-public; it only for use by subclasses, all other code
971
 
        should consider it to be private.
972
 
        """
973
 
        self._revision_history_cache = rev_history
974
 
 
975
 
    def _cache_revision_id_to_revno(self, revision_id_to_revno):
976
 
        """Set the cached revision_id => revno map to revision_id_to_revno.
977
 
 
978
 
        This API is semi-public; it only for use by subclasses, all other code
979
 
        should consider it to be private.
980
 
        """
981
 
        self._revision_id_to_revno_cache = revision_id_to_revno
982
 
 
983
 
    def _clear_cached_state(self):
984
 
        """Clear any cached data on this branch, e.g. cached revision history.
985
 
 
986
 
        This means the next call to revision_history will need to call
987
 
        _gen_revision_history.
988
 
 
989
 
        This API is semi-public; it is only for use by subclasses, all other
990
 
        code should consider it to be private.
991
 
        """
992
 
        self._revision_history_cache = None
993
 
        self._revision_id_to_revno_cache = None
994
 
        self._last_revision_info_cache = None
995
 
        self._master_branch_cache = None
996
 
        self._merge_sorted_revisions_cache = None
997
 
        self._partial_revision_history_cache = []
998
 
        self._partial_revision_id_to_revno_cache = {}
999
 
        self._tags_bytes = None
1000
 
 
1001
 
    def _gen_revision_history(self):
1002
 
        """Return sequence of revision hashes on to this branch.
1003
 
 
1004
 
        Unlike revision_history, this method always regenerates or rereads the
1005
 
        revision history, i.e. it does not cache the result, so repeated calls
1006
 
        may be expensive.
1007
 
 
1008
 
        Concrete subclasses should override this instead of revision_history so
1009
 
        that subclasses do not need to deal with caching logic.
1010
 
 
1011
 
        This API is semi-public; it only for use by subclasses, all other code
1012
 
        should consider it to be private.
1013
 
        """
1014
 
        raise NotImplementedError(self._gen_revision_history)
1015
 
 
1016
 
    def _revision_history(self):
1017
 
        if 'evil' in debug.debug_flags:
1018
 
            mutter_callsite(3, "revision_history scales with history.")
1019
 
        if self._revision_history_cache is not None:
1020
 
            history = self._revision_history_cache
1021
 
        else:
1022
 
            history = self._gen_revision_history()
1023
 
            self._cache_revision_history(history)
1024
 
        return list(history)
 
288
    def append_revision(self, *revision_ids):
 
289
        raise NotImplementedError(self.append_revision)
 
290
 
 
291
    def set_revision_history(self, rev_history):
 
292
        raise NotImplementedError(self.set_revision_history)
 
293
 
 
294
    def revision_history(self):
 
295
        """Return sequence of revision hashes on to this branch."""
 
296
        raise NotImplementedError('revision_history is abstract')
1025
297
 
1026
298
    def revno(self):
1027
299
        """Return current revision number for this branch.
1029
301
        That is equivalent to the number of revisions committed to
1030
302
        this branch.
1031
303
        """
1032
 
        return self.last_revision_info()[0]
 
304
        return len(self.revision_history())
1033
305
 
1034
306
    def unbind(self):
1035
307
        """Older format branches cannot bind or unbind."""
1036
 
        raise errors.UpgradeRequired(self.user_url)
 
308
        raise errors.UpgradeRequired(self.base)
1037
309
 
1038
310
    def last_revision(self):
1039
 
        """Return last revision id, or NULL_REVISION."""
1040
 
        return self.last_revision_info()[1]
1041
 
 
1042
 
    @needs_read_lock
1043
 
    def last_revision_info(self):
1044
 
        """Return information about the last revision.
1045
 
 
1046
 
        :return: A tuple (revno, revision_id).
1047
 
        """
1048
 
        if self._last_revision_info_cache is None:
1049
 
            self._last_revision_info_cache = self._read_last_revision_info()
1050
 
        return self._last_revision_info_cache
1051
 
 
1052
 
    def _read_last_revision_info(self):
1053
 
        raise NotImplementedError(self._read_last_revision_info)
1054
 
 
1055
 
    def import_last_revision_info_and_tags(self, source, revno, revid,
1056
 
                                           lossy=False):
1057
 
        """Set the last revision info, importing from another repo if necessary.
1058
 
 
1059
 
        This is used by the bound branch code to upload a revision to
1060
 
        the master branch first before updating the tip of the local branch.
1061
 
        Revisions referenced by source's tags are also transferred.
1062
 
 
1063
 
        :param source: Source branch to optionally fetch from
1064
 
        :param revno: Revision number of the new tip
1065
 
        :param revid: Revision id of the new tip
1066
 
        :param lossy: Whether to discard metadata that can not be
1067
 
            natively represented
1068
 
        :return: Tuple with the new revision number and revision id
1069
 
            (should only be different from the arguments when lossy=True)
1070
 
        """
1071
 
        if not self.repository.has_same_location(source.repository):
1072
 
            self.fetch(source, revid)
1073
 
        self.set_last_revision_info(revno, revid)
1074
 
        return (revno, revid)
 
311
        """Return last revision id, or None"""
 
312
        ph = self.revision_history()
 
313
        if ph:
 
314
            return ph[-1]
 
315
        else:
 
316
            return None
 
317
 
 
318
    def missing_revisions(self, other, stop_revision=None):
 
319
        """Return a list of new revisions that would perfectly fit.
 
320
        
 
321
        If self and other have not diverged, return a list of the revisions
 
322
        present in other, but missing from self.
 
323
        """
 
324
        self_history = self.revision_history()
 
325
        self_len = len(self_history)
 
326
        other_history = other.revision_history()
 
327
        other_len = len(other_history)
 
328
        common_index = min(self_len, other_len) -1
 
329
        if common_index >= 0 and \
 
330
            self_history[common_index] != other_history[common_index]:
 
331
            raise DivergedBranches(self, other)
 
332
 
 
333
        if stop_revision is None:
 
334
            stop_revision = other_len
 
335
        else:
 
336
            assert isinstance(stop_revision, int)
 
337
            if stop_revision > other_len:
 
338
                raise errors.NoSuchRevision(self, stop_revision)
 
339
        return other_history[self_len:stop_revision]
 
340
 
 
341
    def update_revisions(self, other, stop_revision=None):
 
342
        """Pull in new perfect-fit revisions.
 
343
 
 
344
        :param other: Another Branch to pull from
 
345
        :param stop_revision: Updated until the given revision
 
346
        :return: None
 
347
        """
 
348
        raise NotImplementedError(self.update_revisions)
1075
349
 
1076
350
    def revision_id_to_revno(self, revision_id):
1077
351
        """Given a revision id, return its revno"""
1078
 
        if _mod_revision.is_null(revision_id):
 
352
        if revision_id is None:
1079
353
            return 0
1080
 
        history = self._revision_history()
 
354
        history = self.revision_history()
1081
355
        try:
1082
356
            return history.index(revision_id) + 1
1083
357
        except ValueError:
1084
 
            raise errors.NoSuchRevision(self, revision_id)
 
358
            raise bzrlib.errors.NoSuchRevision(self, revision_id)
1085
359
 
1086
 
    @needs_read_lock
1087
360
    def get_rev_id(self, revno, history=None):
1088
361
        """Find the revision id of the specified revno."""
1089
362
        if revno == 0:
1090
 
            return _mod_revision.NULL_REVISION
1091
 
        last_revno, last_revid = self.last_revision_info()
1092
 
        if revno == last_revno:
1093
 
            return last_revid
1094
 
        if revno <= 0 or revno > last_revno:
1095
 
            raise errors.NoSuchRevision(self, revno)
1096
 
        distance_from_last = last_revno - revno
1097
 
        if len(self._partial_revision_history_cache) <= distance_from_last:
1098
 
            self._extend_partial_history(distance_from_last)
1099
 
        return self._partial_revision_history_cache[distance_from_last]
1100
 
 
1101
 
    def pull(self, source, overwrite=False, stop_revision=None,
1102
 
             possible_transports=None, *args, **kwargs):
1103
 
        """Mirror source into this branch.
1104
 
 
1105
 
        This branch is considered to be 'local', having low latency.
1106
 
 
1107
 
        :returns: PullResult instance
1108
 
        """
1109
 
        return InterBranch.get(source, self).pull(overwrite=overwrite,
1110
 
            stop_revision=stop_revision,
1111
 
            possible_transports=possible_transports, *args, **kwargs)
1112
 
 
1113
 
    def push(self, target, overwrite=False, stop_revision=None, lossy=False,
1114
 
            *args, **kwargs):
1115
 
        """Mirror this branch into target.
1116
 
 
1117
 
        This branch is considered to be 'local', having low latency.
1118
 
        """
1119
 
        return InterBranch.get(self, target).push(overwrite, stop_revision,
1120
 
            lossy, *args, **kwargs)
 
363
            return None
 
364
        if history is None:
 
365
            history = self.revision_history()
 
366
        elif revno <= 0 or revno > len(history):
 
367
            raise bzrlib.errors.NoSuchRevision(self, revno)
 
368
        return history[revno - 1]
 
369
 
 
370
    def pull(self, source, overwrite=False, stop_revision=None):
 
371
        raise NotImplementedError(self.pull)
1121
372
 
1122
373
    def basis_tree(self):
1123
374
        """Return `Tree` object for last revision."""
1124
375
        return self.repository.revision_tree(self.last_revision())
1125
376
 
 
377
    def rename_one(self, from_rel, to_rel):
 
378
        """Rename one file.
 
379
 
 
380
        This can change the directory or the filename or both.
 
381
        """
 
382
        raise NotImplementedError(self.rename_one)
 
383
 
 
384
    def move(self, from_paths, to_name):
 
385
        """Rename files.
 
386
 
 
387
        to_name must exist as a versioned directory.
 
388
 
 
389
        If to_name exists and is a directory, the files are moved into
 
390
        it, keeping their old names.  If it is a directory, 
 
391
 
 
392
        Note that to_name is only the last component of the new name;
 
393
        this doesn't change the directory.
 
394
 
 
395
        This returns a list of (from_path, to_path) pairs for each
 
396
        entry that is moved.
 
397
        """
 
398
        raise NotImplementedError(self.move)
 
399
 
1126
400
    def get_parent(self):
1127
401
        """Return the parent location of the branch.
1128
402
 
1129
 
        This is the default location for pull/missing.  The usual
 
403
        This is the default location for push/pull/missing.  The usual
1130
404
        pattern is that the user can override it by specifying a
1131
405
        location.
1132
406
        """
1133
 
        parent = self._get_parent_location()
1134
 
        if parent is None:
1135
 
            return parent
1136
 
        # This is an old-format absolute path to a local branch
1137
 
        # turn it into a url
1138
 
        if parent.startswith('/'):
1139
 
            parent = urlutils.local_path_to_url(parent.decode('utf8'))
1140
 
        try:
1141
 
            return urlutils.join(self.base[:-1], parent)
1142
 
        except errors.InvalidURLJoin, e:
1143
 
            raise errors.InaccessibleParent(parent, self.user_url)
1144
 
 
1145
 
    def _get_parent_location(self):
1146
 
        raise NotImplementedError(self._get_parent_location)
1147
 
 
1148
 
    def _set_config_location(self, name, url, config=None,
1149
 
                             make_relative=False):
1150
 
        if config is None:
1151
 
            config = self.get_config_stack()
1152
 
        if url is None:
1153
 
            url = ''
1154
 
        elif make_relative:
1155
 
            url = urlutils.relative_url(self.base, url)
1156
 
        config.set(name, url)
1157
 
 
1158
 
    def _get_config_location(self, name, config=None):
1159
 
        if config is None:
1160
 
            config = self.get_config_stack()
1161
 
        location = config.get(name)
1162
 
        if location == '':
1163
 
            location = None
1164
 
        return location
1165
 
 
1166
 
    def get_child_submit_format(self):
1167
 
        """Return the preferred format of submissions to this branch."""
1168
 
        return self.get_config_stack().get('child_submit_format')
 
407
        raise NotImplementedError(self.get_parent)
1169
408
 
1170
409
    def get_submit_branch(self):
1171
410
        """Return the submit location of the branch.
1174
413
        pattern is that the user can override it by specifying a
1175
414
        location.
1176
415
        """
1177
 
        return self.get_config_stack().get('submit_branch')
 
416
        return self.get_config().get_user_option('submit_branch')
1178
417
 
1179
418
    def set_submit_branch(self, location):
1180
419
        """Return the submit location of the branch.
1183
422
        pattern is that the user can override it by specifying a
1184
423
        location.
1185
424
        """
1186
 
        self.get_config_stack().set('submit_branch', location)
1187
 
 
1188
 
    def get_public_branch(self):
1189
 
        """Return the public location of the branch.
1190
 
 
1191
 
        This is used by merge directives.
1192
 
        """
1193
 
        return self._get_config_location('public_branch')
1194
 
 
1195
 
    def set_public_branch(self, location):
1196
 
        """Return the submit location of the branch.
1197
 
 
1198
 
        This is the default location for bundle.  The usual
1199
 
        pattern is that the user can override it by specifying a
1200
 
        location.
1201
 
        """
1202
 
        self._set_config_location('public_branch', location)
 
425
        self.get_config().set_user_option('submit_branch', location)
1203
426
 
1204
427
    def get_push_location(self):
1205
 
        """Return None or the location to push this branch to."""
1206
 
        return self.get_config_stack().get('push_location')
 
428
        """Return the None or the location to push this branch to."""
 
429
        raise NotImplementedError(self.get_push_location)
1207
430
 
1208
431
    def set_push_location(self, location):
1209
432
        """Set a new push location for this branch."""
1210
433
        raise NotImplementedError(self.set_push_location)
1211
434
 
1212
 
    def _run_post_change_branch_tip_hooks(self, old_revno, old_revid):
1213
 
        """Run the post_change_branch_tip hooks."""
1214
 
        hooks = Branch.hooks['post_change_branch_tip']
1215
 
        if not hooks:
1216
 
            return
1217
 
        new_revno, new_revid = self.last_revision_info()
1218
 
        params = ChangeBranchTipParams(
1219
 
            self, old_revno, new_revno, old_revid, new_revid)
1220
 
        for hook in hooks:
1221
 
            hook(params)
1222
 
 
1223
 
    def _run_pre_change_branch_tip_hooks(self, new_revno, new_revid):
1224
 
        """Run the pre_change_branch_tip hooks."""
1225
 
        hooks = Branch.hooks['pre_change_branch_tip']
1226
 
        if not hooks:
1227
 
            return
1228
 
        old_revno, old_revid = self.last_revision_info()
1229
 
        params = ChangeBranchTipParams(
1230
 
            self, old_revno, new_revno, old_revid, new_revid)
1231
 
        for hook in hooks:
1232
 
            hook(params)
 
435
    def set_parent(self, url):
 
436
        raise NotImplementedError(self.set_parent)
1233
437
 
1234
438
    @needs_write_lock
1235
439
    def update(self):
1236
 
        """Synchronise this branch with the master branch if any.
 
440
        """Synchronise this branch with the master branch if any. 
1237
441
 
1238
442
        :return: None or the last_revision pivoted out during the update.
1239
443
        """
1246
450
        """
1247
451
        if revno != 0:
1248
452
            self.check_real_revno(revno)
1249
 
 
 
453
            
1250
454
    def check_real_revno(self, revno):
1251
455
        """\
1252
456
        Check whether a revno corresponds to a real revision.
1253
457
        Zero (the NULL revision) is considered invalid
1254
458
        """
1255
459
        if revno < 1 or revno > self.revno():
1256
 
            raise errors.InvalidRevisionNumber(revno)
 
460
            raise InvalidRevisionNumber(revno)
1257
461
 
1258
462
    @needs_read_lock
1259
 
    def clone(self, to_bzrdir, revision_id=None, repository_policy=None):
 
463
    def clone(self, *args, **kwargs):
1260
464
        """Clone this branch into to_bzrdir preserving all semantic values.
1261
 
 
1262
 
        Most API users will want 'create_clone_on_transport', which creates a
1263
 
        new bzrdir and branch on the fly.
1264
 
 
 
465
        
1265
466
        revision_id: if not None, the revision history in the new branch will
1266
467
                     be truncated to end with revision_id.
1267
468
        """
1268
 
        result = to_bzrdir.create_branch()
1269
 
        result.lock_write()
1270
 
        try:
1271
 
            if repository_policy is not None:
1272
 
                repository_policy.configure_branch(result)
1273
 
            self.copy_content_into(result, revision_id=revision_id)
1274
 
        finally:
1275
 
            result.unlock()
1276
 
        return result
 
469
        # for API compatibility, until 0.8 releases we provide the old api:
 
470
        # def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
 
471
        # after 0.8 releases, the *args and **kwargs should be changed:
 
472
        # def clone(self, to_bzrdir, revision_id=None):
 
473
        if (kwargs.get('to_location', None) or
 
474
            kwargs.get('revision', None) or
 
475
            kwargs.get('basis_branch', None) or
 
476
            (len(args) and isinstance(args[0], basestring))):
 
477
            # backwards compatibility api:
 
478
            warn("Branch.clone() has been deprecated for BzrDir.clone() from"
 
479
                 " bzrlib 0.8.", DeprecationWarning, stacklevel=3)
 
480
            # get basis_branch
 
481
            if len(args) > 2:
 
482
                basis_branch = args[2]
 
483
            else:
 
484
                basis_branch = kwargs.get('basis_branch', None)
 
485
            if basis_branch:
 
486
                basis = basis_branch.bzrdir
 
487
            else:
 
488
                basis = None
 
489
            # get revision
 
490
            if len(args) > 1:
 
491
                revision_id = args[1]
 
492
            else:
 
493
                revision_id = kwargs.get('revision', None)
 
494
            # get location
 
495
            if len(args):
 
496
                url = args[0]
 
497
            else:
 
498
                # no default to raise if not provided.
 
499
                url = kwargs.get('to_location')
 
500
            return self.bzrdir.clone(url,
 
501
                                     revision_id=revision_id,
 
502
                                     basis=basis).open_branch()
 
503
        # new cleaner api.
 
504
        # generate args by hand 
 
505
        if len(args) > 1:
 
506
            revision_id = args[1]
 
507
        else:
 
508
            revision_id = kwargs.get('revision_id', None)
 
509
        if len(args):
 
510
            to_bzrdir = args[0]
 
511
        else:
 
512
            # no default to raise if not provided.
 
513
            to_bzrdir = kwargs.get('to_bzrdir')
 
514
        result = self._format.initialize(to_bzrdir)
 
515
        self.copy_content_into(result, revision_id=revision_id)
 
516
        return  result
1277
517
 
1278
518
    @needs_read_lock
1279
 
    def sprout(self, to_bzrdir, revision_id=None, repository_policy=None,
1280
 
            repository=None):
 
519
    def sprout(self, to_bzrdir, revision_id=None):
1281
520
        """Create a new line of development from the branch, into to_bzrdir.
1282
 
 
1283
 
        to_bzrdir controls the branch format.
1284
 
 
 
521
        
1285
522
        revision_id: if not None, the revision history in the new branch will
1286
523
                     be truncated to end with revision_id.
1287
524
        """
1288
 
        if (repository_policy is not None and
1289
 
            repository_policy.requires_stacking()):
1290
 
            to_bzrdir._format.require_stacking(_skip_repo=True)
1291
 
        result = to_bzrdir.create_branch(repository=repository)
1292
 
        result.lock_write()
1293
 
        try:
1294
 
            if repository_policy is not None:
1295
 
                repository_policy.configure_branch(result)
1296
 
            self.copy_content_into(result, revision_id=revision_id)
1297
 
            master_url = self.get_bound_location()
1298
 
            if master_url is None:
1299
 
                result.set_parent(self.bzrdir.root_transport.base)
1300
 
            else:
1301
 
                result.set_parent(master_url)
1302
 
        finally:
1303
 
            result.unlock()
 
525
        result = self._format.initialize(to_bzrdir)
 
526
        self.copy_content_into(result, revision_id=revision_id)
 
527
        result.set_parent(self.bzrdir.root_transport.base)
1304
528
        return result
1305
529
 
1306
 
    def _synchronize_history(self, destination, revision_id):
1307
 
        """Synchronize last revision and revision history between branches.
1308
 
 
1309
 
        This version is most efficient when the destination is also a
1310
 
        BzrBranch6, but works for BzrBranch5, as long as the destination's
1311
 
        repository contains all the lefthand ancestors of the intended
1312
 
        last_revision.  If not, set_last_revision_info will fail.
1313
 
 
1314
 
        :param destination: The branch to copy the history into
1315
 
        :param revision_id: The revision-id to truncate history at.  May
1316
 
          be None to copy complete history.
1317
 
        """
1318
 
        source_revno, source_revision_id = self.last_revision_info()
1319
 
        if revision_id is None:
1320
 
            revno, revision_id = source_revno, source_revision_id
1321
 
        else:
1322
 
            graph = self.repository.get_graph()
1323
 
            try:
1324
 
                revno = graph.find_distance_to_null(revision_id, 
1325
 
                    [(source_revision_id, source_revno)])
1326
 
            except errors.GhostRevisionsHaveNoRevno:
1327
 
                # Default to 1, if we can't find anything else
1328
 
                revno = 1
1329
 
        destination.set_last_revision_info(revno, revision_id)
1330
 
 
 
530
    @needs_read_lock
1331
531
    def copy_content_into(self, destination, revision_id=None):
1332
532
        """Copy the content of self into destination.
1333
533
 
1334
534
        revision_id: if not None, the revision history in the new branch will
1335
535
                     be truncated to end with revision_id.
1336
536
        """
1337
 
        return InterBranch.get(self, destination).copy_content_into(
1338
 
            revision_id=revision_id)
1339
 
 
1340
 
    def update_references(self, target):
1341
 
        if not getattr(self._format, 'supports_reference_locations', False):
1342
 
            return
1343
 
        reference_dict = self._get_all_reference_info()
1344
 
        if len(reference_dict) == 0:
1345
 
            return
1346
 
        old_base = self.base
1347
 
        new_base = target.base
1348
 
        target_reference_dict = target._get_all_reference_info()
1349
 
        for file_id, (tree_path, branch_location) in (
1350
 
            reference_dict.items()):
1351
 
            branch_location = urlutils.rebase_url(branch_location,
1352
 
                                                  old_base, new_base)
1353
 
            target_reference_dict.setdefault(
1354
 
                file_id, (tree_path, branch_location))
1355
 
        target._set_all_reference_info(target_reference_dict)
 
537
        new_history = self.revision_history()
 
538
        if revision_id is not None:
 
539
            try:
 
540
                new_history = new_history[:new_history.index(revision_id) + 1]
 
541
            except ValueError:
 
542
                rev = self.repository.get_revision(revision_id)
 
543
                new_history = rev.get_history(self.repository)[1:]
 
544
        destination.set_revision_history(new_history)
 
545
        try:
 
546
            parent = self.get_parent()
 
547
        except errors.InaccessibleParent, e:
 
548
            mutter('parent was not accessible to copy: %s', e)
 
549
        else:
 
550
            if parent:
 
551
                destination.set_parent(parent)
1356
552
 
1357
553
    @needs_read_lock
1358
 
    def check(self, refs):
 
554
    def check(self):
1359
555
        """Check consistency of the branch.
1360
556
 
1361
557
        In particular this checks that revisions given in the revision-history
1362
 
        do actually match up in the revision graph, and that they're all
 
558
        do actually match up in the revision graph, and that they're all 
1363
559
        present in the repository.
1364
 
 
 
560
        
1365
561
        Callers will typically also want to check the repository.
1366
562
 
1367
 
        :param refs: Calculated refs for this branch as specified by
1368
 
            branch._get_check_refs()
1369
563
        :return: A BranchCheckResult.
1370
564
        """
1371
 
        result = BranchCheckResult(self)
1372
 
        last_revno, last_revision_id = self.last_revision_info()
1373
 
        actual_revno = refs[('lefthand-distance', last_revision_id)]
1374
 
        if actual_revno != last_revno:
1375
 
            result.errors.append(errors.BzrCheckError(
1376
 
                'revno does not match len(mainline) %s != %s' % (
1377
 
                last_revno, actual_revno)))
1378
 
        # TODO: We should probably also check that self.revision_history
1379
 
        # matches the repository for older branch formats.
1380
 
        # If looking for the code that cross-checks repository parents against
1381
 
        # the Graph.iter_lefthand_ancestry output, that is now a repository
1382
 
        # specific check.
1383
 
        return result
1384
 
 
1385
 
    def _get_checkout_format(self, lightweight=False):
1386
 
        """Return the most suitable metadir for a checkout of this branch.
1387
 
        Weaves are used if this branch's repository uses weaves.
1388
 
        """
1389
 
        format = self.repository.bzrdir.checkout_metadir()
1390
 
        format.set_branch_format(self._format)
1391
 
        return format
1392
 
 
1393
 
    def create_clone_on_transport(self, to_transport, revision_id=None,
1394
 
        stacked_on=None, create_prefix=False, use_existing_dir=False,
1395
 
        no_tree=None):
1396
 
        """Create a clone of this branch and its bzrdir.
1397
 
 
1398
 
        :param to_transport: The transport to clone onto.
1399
 
        :param revision_id: The revision id to use as tip in the new branch.
1400
 
            If None the tip is obtained from this branch.
1401
 
        :param stacked_on: An optional URL to stack the clone on.
1402
 
        :param create_prefix: Create any missing directories leading up to
1403
 
            to_transport.
1404
 
        :param use_existing_dir: Use an existing directory if one exists.
1405
 
        """
1406
 
        # XXX: Fix the bzrdir API to allow getting the branch back from the
1407
 
        # clone call. Or something. 20090224 RBC/spiv.
1408
 
        # XXX: Should this perhaps clone colocated branches as well, 
1409
 
        # rather than just the default branch? 20100319 JRV
1410
 
        if revision_id is None:
1411
 
            revision_id = self.last_revision()
1412
 
        dir_to = self.bzrdir.clone_on_transport(to_transport,
1413
 
            revision_id=revision_id, stacked_on=stacked_on,
1414
 
            create_prefix=create_prefix, use_existing_dir=use_existing_dir,
1415
 
            no_tree=no_tree)
1416
 
        return dir_to.open_branch()
1417
 
 
1418
 
    def create_checkout(self, to_location, revision_id=None,
1419
 
                        lightweight=False, accelerator_tree=None,
1420
 
                        hardlink=False):
 
565
        mainline_parent_id = None
 
566
        for revision_id in self.revision_history():
 
567
            try:
 
568
                revision = self.repository.get_revision(revision_id)
 
569
            except errors.NoSuchRevision, e:
 
570
                raise errors.BzrCheckError("mainline revision {%s} not in repository"
 
571
                            % revision_id)
 
572
            # In general the first entry on the revision history has no parents.
 
573
            # But it's not illegal for it to have parents listed; this can happen
 
574
            # in imports from Arch when the parents weren't reachable.
 
575
            if mainline_parent_id is not None:
 
576
                if mainline_parent_id not in revision.parent_ids:
 
577
                    raise errors.BzrCheckError("previous revision {%s} not listed among "
 
578
                                        "parents of {%s}"
 
579
                                        % (mainline_parent_id, revision_id))
 
580
            mainline_parent_id = revision_id
 
581
        return BranchCheckResult(self)
 
582
 
 
583
    def create_checkout(self, to_location, revision_id=None, 
 
584
                        lightweight=False):
1421
585
        """Create a checkout of a branch.
1422
 
 
 
586
        
1423
587
        :param to_location: The url to produce the checkout at
1424
588
        :param revision_id: The revision to check out
1425
589
        :param lightweight: If True, produce a lightweight checkout, otherwise,
1426
 
            produce a bound branch (heavyweight checkout)
1427
 
        :param accelerator_tree: A tree which can be used for retrieving file
1428
 
            contents more quickly than the revision tree, i.e. a workingtree.
1429
 
            The revision tree will be used for cases where accelerator_tree's
1430
 
            content is different.
1431
 
        :param hardlink: If true, hard-link files from accelerator_tree,
1432
 
            where possible.
 
590
        produce a bound branch (heavyweight checkout)
1433
591
        :return: The tree of the created checkout
1434
592
        """
1435
 
        t = transport.get_transport(to_location)
1436
 
        t.ensure_base()
1437
 
        format = self._get_checkout_format(lightweight=lightweight)
1438
 
        try:
1439
 
            checkout = format.initialize_on_transport(t)
1440
 
        except errors.AlreadyControlDirError:
1441
 
            # It's fine if the control directory already exists,
1442
 
            # as long as there is no existing branch and working tree.
1443
 
            checkout = controldir.ControlDir.open_from_transport(t)
1444
 
            try:
1445
 
                checkout.open_branch()
1446
 
            except errors.NotBranchError:
1447
 
                pass
1448
 
            else:
1449
 
                raise errors.AlreadyControlDirError(t.base)
1450
 
            if checkout.control_transport.base == self.bzrdir.control_transport.base:
1451
 
                # When checking out to the same control directory,
1452
 
                # always create a lightweight checkout
1453
 
                lightweight = True
1454
 
 
1455
593
        if lightweight:
1456
 
            from_branch = checkout.set_branch_reference(target_branch=self)
 
594
            t = transport.get_transport(to_location)
 
595
            try:
 
596
                t.mkdir('.')
 
597
            except errors.FileExists:
 
598
                pass
 
599
            checkout = bzrdir.BzrDirMetaFormat1().initialize_on_transport(t)
 
600
            BranchReferenceFormat().initialize(checkout, self)
1457
601
        else:
1458
 
            policy = checkout.determine_repository_policy()
1459
 
            repo = policy.acquire_repository()[0]
1460
 
            checkout_branch = checkout.create_branch()
 
602
            checkout_branch = bzrdir.BzrDir.create_branch_convenience(
 
603
                to_location, force_new_tree=False)
 
604
            checkout = checkout_branch.bzrdir
1461
605
            checkout_branch.bind(self)
1462
 
            # pull up to the specified revision_id to set the initial
1463
 
            # branch tip correctly, and seed it with history.
1464
 
            checkout_branch.pull(self, stop_revision=revision_id)
1465
 
            from_branch = None
1466
 
        tree = checkout.create_workingtree(revision_id,
1467
 
                                           from_branch=from_branch,
1468
 
                                           accelerator_tree=accelerator_tree,
1469
 
                                           hardlink=hardlink)
1470
 
        basis_tree = tree.basis_tree()
1471
 
        basis_tree.lock_read()
1472
 
        try:
1473
 
            for path, file_id in basis_tree.iter_references():
1474
 
                reference_parent = self.reference_parent(file_id, path)
1475
 
                reference_parent.create_checkout(tree.abspath(path),
1476
 
                    basis_tree.get_reference_revision(file_id, path),
1477
 
                    lightweight)
1478
 
        finally:
1479
 
            basis_tree.unlock()
1480
 
        return tree
1481
 
 
1482
 
    @needs_write_lock
1483
 
    def reconcile(self, thorough=True):
1484
 
        """Make sure the data stored in this branch is consistent."""
1485
 
        from bzrlib.reconcile import BranchReconciler
1486
 
        reconciler = BranchReconciler(self, thorough=thorough)
1487
 
        reconciler.reconcile()
1488
 
        return reconciler
1489
 
 
1490
 
    def reference_parent(self, file_id, path, possible_transports=None):
1491
 
        """Return the parent branch for a tree-reference file_id
1492
 
 
1493
 
        :param file_id: The file_id of the tree reference
1494
 
        :param path: The path of the file_id in the tree
1495
 
        :return: A branch associated with the file_id
1496
 
        """
1497
 
        # FIXME should provide multiple branches, based on config
1498
 
        return Branch.open(self.bzrdir.root_transport.clone(path).base,
1499
 
                           possible_transports=possible_transports)
1500
 
 
1501
 
    def supports_tags(self):
1502
 
        return self._format.supports_tags()
1503
 
 
1504
 
    def automatic_tag_name(self, revision_id):
1505
 
        """Try to automatically find the tag name for a revision.
1506
 
 
1507
 
        :param revision_id: Revision id of the revision.
1508
 
        :return: A tag name or None if no tag name could be determined.
1509
 
        """
1510
 
        for hook in Branch.hooks['automatic_tag_name']:
1511
 
            ret = hook(self, revision_id)
1512
 
            if ret is not None:
1513
 
                return ret
1514
 
        return None
1515
 
 
1516
 
    def _check_if_descendant_or_diverged(self, revision_a, revision_b, graph,
1517
 
                                         other_branch):
1518
 
        """Ensure that revision_b is a descendant of revision_a.
1519
 
 
1520
 
        This is a helper function for update_revisions.
1521
 
 
1522
 
        :raises: DivergedBranches if revision_b has diverged from revision_a.
1523
 
        :returns: True if revision_b is a descendant of revision_a.
1524
 
        """
1525
 
        relation = self._revision_relations(revision_a, revision_b, graph)
1526
 
        if relation == 'b_descends_from_a':
1527
 
            return True
1528
 
        elif relation == 'diverged':
1529
 
            raise errors.DivergedBranches(self, other_branch)
1530
 
        elif relation == 'a_descends_from_b':
1531
 
            return False
1532
 
        else:
1533
 
            raise AssertionError("invalid relation: %r" % (relation,))
1534
 
 
1535
 
    def _revision_relations(self, revision_a, revision_b, graph):
1536
 
        """Determine the relationship between two revisions.
1537
 
 
1538
 
        :returns: One of: 'a_descends_from_b', 'b_descends_from_a', 'diverged'
1539
 
        """
1540
 
        heads = graph.heads([revision_a, revision_b])
1541
 
        if heads == set([revision_b]):
1542
 
            return 'b_descends_from_a'
1543
 
        elif heads == set([revision_a, revision_b]):
1544
 
            # These branches have diverged
1545
 
            return 'diverged'
1546
 
        elif heads == set([revision_a]):
1547
 
            return 'a_descends_from_b'
1548
 
        else:
1549
 
            raise AssertionError("invalid heads: %r" % (heads,))
1550
 
 
1551
 
    def heads_to_fetch(self):
1552
 
        """Return the heads that must and that should be fetched to copy this
1553
 
        branch into another repo.
1554
 
 
1555
 
        :returns: a 2-tuple of (must_fetch, if_present_fetch).  must_fetch is a
1556
 
            set of heads that must be fetched.  if_present_fetch is a set of
1557
 
            heads that must be fetched if present, but no error is necessary if
1558
 
            they are not present.
1559
 
        """
1560
 
        # For bzr native formats must_fetch is just the tip, and
1561
 
        # if_present_fetch are the tags.
1562
 
        must_fetch = set([self.last_revision()])
1563
 
        if_present_fetch = set()
1564
 
        if self.get_config_stack().get('branch.fetch_tags'):
1565
 
            try:
1566
 
                if_present_fetch = set(self.tags.get_reverse_tag_dict())
1567
 
            except errors.TagsNotSupported:
1568
 
                pass
1569
 
        must_fetch.discard(_mod_revision.NULL_REVISION)
1570
 
        if_present_fetch.discard(_mod_revision.NULL_REVISION)
1571
 
        return must_fetch, if_present_fetch
1572
 
 
1573
 
 
1574
 
class BranchFormat(controldir.ControlComponentFormat):
 
606
            if revision_id is not None:
 
607
                rh = checkout_branch.revision_history()
 
608
                new_rh = rh[:rh.index(revision_id) + 1]
 
609
                checkout_branch.set_revision_history(new_rh)
 
610
        return checkout.create_workingtree(revision_id)
 
611
 
 
612
 
 
613
class BranchFormat(object):
1575
614
    """An encapsulation of the initialization and open routines for a format.
1576
615
 
1577
616
    Formats provide three things:
1578
617
     * An initialization routine,
1579
 
     * a format description
 
618
     * a format string,
1580
619
     * an open routine.
1581
620
 
1582
 
    Formats are placed in an dict by their format string for reference
1583
 
    during branch opening. It's not required that these be instances, they
1584
 
    can be classes themselves with class methods - it simply depends on
 
621
    Formats are placed in an dict by their format string for reference 
 
622
    during branch opening. Its not required that these be instances, they
 
623
    can be classes themselves with class methods - it simply depends on 
1585
624
    whether state is needed for a given format or not.
1586
625
 
1587
626
    Once a format is deprecated, just deprecate the initialize and open
1588
 
    methods on the format class. Do not deprecate the object, as the
 
627
    methods on the format class. Do not deprecate the object, as the 
1589
628
    object will be created every time regardless.
1590
629
    """
1591
630
 
1592
 
    def __eq__(self, other):
1593
 
        return self.__class__ is other.__class__
1594
 
 
1595
 
    def __ne__(self, other):
1596
 
        return not (self == other)
1597
 
 
1598
 
    def get_reference(self, controldir, name=None):
1599
 
        """Get the target reference of the branch in controldir.
1600
 
 
1601
 
        format probing must have been completed before calling
1602
 
        this method - it is assumed that the format of the branch
1603
 
        in controldir is correct.
1604
 
 
1605
 
        :param controldir: The controldir to get the branch data from.
1606
 
        :param name: Name of the colocated branch to fetch
1607
 
        :return: None if the branch is not a reference branch.
1608
 
        """
1609
 
        return None
1610
 
 
1611
 
    @classmethod
1612
 
    def set_reference(self, controldir, name, to_branch):
1613
 
        """Set the target reference of the branch in controldir.
1614
 
 
1615
 
        format probing must have been completed before calling
1616
 
        this method - it is assumed that the format of the branch
1617
 
        in controldir is correct.
1618
 
 
1619
 
        :param controldir: The controldir to set the branch reference for.
1620
 
        :param name: Name of colocated branch to set, None for default
1621
 
        :param to_branch: branch that the checkout is to reference
1622
 
        """
1623
 
        raise NotImplementedError(self.set_reference)
 
631
    _default_format = None
 
632
    """The default format used for new branches."""
 
633
 
 
634
    _formats = {}
 
635
    """The known formats."""
 
636
 
 
637
    @classmethod
 
638
    def find_format(klass, a_bzrdir):
 
639
        """Return the format for the branch object in a_bzrdir."""
 
640
        try:
 
641
            transport = a_bzrdir.get_branch_transport(None)
 
642
            format_string = transport.get("format").read()
 
643
            return klass._formats[format_string]
 
644
        except NoSuchFile:
 
645
            raise NotBranchError(path=transport.base)
 
646
        except KeyError:
 
647
            raise errors.UnknownFormatError(format=format_string)
 
648
 
 
649
    @classmethod
 
650
    def get_default_format(klass):
 
651
        """Return the current default format."""
 
652
        return klass._default_format
 
653
 
 
654
    def get_format_string(self):
 
655
        """Return the ASCII format string that identifies this format."""
 
656
        raise NotImplementedError(self.get_format_string)
1624
657
 
1625
658
    def get_format_description(self):
1626
659
        """Return the short format description for this format."""
1627
 
        raise NotImplementedError(self.get_format_description)
1628
 
 
1629
 
    def _run_post_branch_init_hooks(self, controldir, name, branch):
1630
 
        hooks = Branch.hooks['post_branch_init']
1631
 
        if not hooks:
1632
 
            return
1633
 
        params = BranchInitHookParams(self, controldir, name, branch)
1634
 
        for hook in hooks:
1635
 
            hook(params)
1636
 
 
1637
 
    def initialize(self, controldir, name=None, repository=None,
1638
 
                   append_revisions_only=None):
1639
 
        """Create a branch of this format in controldir.
1640
 
 
1641
 
        :param name: Name of the colocated branch to create.
1642
 
        """
 
660
        raise NotImplementedError(self.get_format_string)
 
661
 
 
662
    def initialize(self, a_bzrdir):
 
663
        """Create a branch of this format in a_bzrdir."""
1643
664
        raise NotImplementedError(self.initialize)
1644
665
 
1645
666
    def is_supported(self):
1646
667
        """Is this format supported?
1647
668
 
1648
669
        Supported formats can be initialized and opened.
1649
 
        Unsupported formats may not support initialization or committing or
 
670
        Unsupported formats may not support initialization or committing or 
1650
671
        some other features depending on the reason for not being supported.
1651
672
        """
1652
673
        return True
1653
674
 
1654
 
    def make_tags(self, branch):
1655
 
        """Create a tags object for branch.
1656
 
 
1657
 
        This method is on BranchFormat, because BranchFormats are reflected
1658
 
        over the wire via network_name(), whereas full Branch instances require
1659
 
        multiple VFS method calls to operate at all.
1660
 
 
1661
 
        The default implementation returns a disabled-tags instance.
1662
 
 
1663
 
        Note that it is normal for branch to be a RemoteBranch when using tags
1664
 
        on a RemoteBranch.
1665
 
        """
1666
 
        return _mod_tag.DisabledTags(branch)
1667
 
 
1668
 
    def network_name(self):
1669
 
        """A simple byte string uniquely identifying this format for RPC calls.
1670
 
 
1671
 
        MetaDir branch formats use their disk format string to identify the
1672
 
        repository over the wire. All in one formats such as bzr < 0.8, and
1673
 
        foreign formats like svn/git and hg should use some marker which is
1674
 
        unique and immutable.
1675
 
        """
1676
 
        raise NotImplementedError(self.network_name)
1677
 
 
1678
 
    def open(self, controldir, name=None, _found=False, ignore_fallbacks=False,
1679
 
            found_repository=None, possible_transports=None):
1680
 
        """Return the branch object for controldir.
1681
 
 
1682
 
        :param controldir: A ControlDir that contains a branch.
1683
 
        :param name: Name of colocated branch to open
1684
 
        :param _found: a private parameter, do not use it. It is used to
1685
 
            indicate if format probing has already be done.
1686
 
        :param ignore_fallbacks: when set, no fallback branches will be opened
1687
 
            (if there are any).  Default is to open fallbacks.
 
675
    def open(self, a_bzrdir, _found=False):
 
676
        """Return the branch object for a_bzrdir
 
677
 
 
678
        _found is a private parameter, do not use it. It is used to indicate
 
679
               if format probing has already be done.
1688
680
        """
1689
681
        raise NotImplementedError(self.open)
1690
682
 
1691
 
    def supports_set_append_revisions_only(self):
1692
 
        """True if this format supports set_append_revisions_only."""
1693
 
        return False
1694
 
 
1695
 
    def supports_stacking(self):
1696
 
        """True if this format records a stacked-on branch."""
1697
 
        return False
1698
 
 
1699
 
    def supports_leaving_lock(self):
1700
 
        """True if this format supports leaving locks in place."""
1701
 
        return False # by default
 
683
    @classmethod
 
684
    def register_format(klass, format):
 
685
        klass._formats[format.get_format_string()] = format
 
686
 
 
687
    @classmethod
 
688
    def set_default_format(klass, format):
 
689
        klass._default_format = format
 
690
 
 
691
    @classmethod
 
692
    def unregister_format(klass, format):
 
693
        assert klass._formats[format.get_format_string()] is format
 
694
        del klass._formats[format.get_format_string()]
1702
695
 
1703
696
    def __str__(self):
1704
 
        return self.get_format_description().rstrip()
1705
 
 
1706
 
    def supports_tags(self):
1707
 
        """True if this format supports tags stored in the branch"""
1708
 
        return False  # by default
1709
 
 
1710
 
    def tags_are_versioned(self):
1711
 
        """Whether the tag container for this branch versions tags."""
1712
 
        return False
1713
 
 
1714
 
    def supports_tags_referencing_ghosts(self):
1715
 
        """True if tags can reference ghost revisions."""
1716
 
        return True
1717
 
 
1718
 
 
1719
 
class MetaDirBranchFormatFactory(registry._LazyObjectGetter):
1720
 
    """A factory for a BranchFormat object, permitting simple lazy registration.
1721
 
    
1722
 
    While none of the built in BranchFormats are lazy registered yet,
1723
 
    bzrlib.tests.test_branch.TestMetaDirBranchFormatFactory demonstrates how to
1724
 
    use it, and the bzr-loom plugin uses it as well (see
1725
 
    bzrlib.plugins.loom.formats).
 
697
        return self.get_format_string().rstrip()
 
698
 
 
699
 
 
700
class BzrBranchFormat4(BranchFormat):
 
701
    """Bzr branch format 4.
 
702
 
 
703
    This format has:
 
704
     - a revision-history file.
 
705
     - a branch-lock lock file [ to be shared with the bzrdir ]
1726
706
    """
1727
707
 
1728
 
    def __init__(self, format_string, module_name, member_name):
1729
 
        """Create a MetaDirBranchFormatFactory.
1730
 
 
1731
 
        :param format_string: The format string the format has.
1732
 
        :param module_name: Module to load the format class from.
1733
 
        :param member_name: Attribute name within the module for the format class.
 
708
    def get_format_description(self):
 
709
        """See BranchFormat.get_format_description()."""
 
710
        return "Branch format 4"
 
711
 
 
712
    def initialize(self, a_bzrdir):
 
713
        """Create a branch of this format in a_bzrdir."""
 
714
        mutter('creating branch in %s', a_bzrdir.transport.base)
 
715
        branch_transport = a_bzrdir.get_branch_transport(self)
 
716
        utf8_files = [('revision-history', ''),
 
717
                      ('branch-name', ''),
 
718
                      ]
 
719
        control_files = LockableFiles(branch_transport, 'branch-lock',
 
720
                                      TransportLock)
 
721
        control_files.create_lock()
 
722
        control_files.lock_write()
 
723
        try:
 
724
            for file, content in utf8_files:
 
725
                control_files.put_utf8(file, content)
 
726
        finally:
 
727
            control_files.unlock()
 
728
        return self.open(a_bzrdir, _found=True)
 
729
 
 
730
    def __init__(self):
 
731
        super(BzrBranchFormat4, self).__init__()
 
732
        self._matchingbzrdir = bzrdir.BzrDirFormat6()
 
733
 
 
734
    def open(self, a_bzrdir, _found=False):
 
735
        """Return the branch object for a_bzrdir
 
736
 
 
737
        _found is a private parameter, do not use it. It is used to indicate
 
738
               if format probing has already be done.
1734
739
        """
1735
 
        registry._LazyObjectGetter.__init__(self, module_name, member_name)
1736
 
        self._format_string = format_string
 
740
        if not _found:
 
741
            # we are being called directly and must probe.
 
742
            raise NotImplementedError
 
743
        return BzrBranch(_format=self,
 
744
                         _control_files=a_bzrdir._control_files,
 
745
                         a_bzrdir=a_bzrdir,
 
746
                         _repository=a_bzrdir.open_repository())
 
747
 
 
748
    def __str__(self):
 
749
        return "Bazaar-NG branch format 4"
 
750
 
 
751
 
 
752
class BzrBranchFormat5(BranchFormat):
 
753
    """Bzr branch format 5.
 
754
 
 
755
    This format has:
 
756
     - a revision-history file.
 
757
     - a format string
 
758
     - a lock dir guarding the branch itself
 
759
     - all of this stored in a branch/ subdirectory
 
760
     - works with shared repositories.
 
761
 
 
762
    This format is new in bzr 0.8.
 
763
    """
1737
764
 
1738
765
    def get_format_string(self):
1739
 
        """See BranchFormat.get_format_string."""
1740
 
        return self._format_string
1741
 
 
1742
 
    def __call__(self):
1743
 
        """Used for network_format_registry support."""
1744
 
        return self.get_obj()()
1745
 
 
1746
 
 
1747
 
class BranchHooks(Hooks):
1748
 
    """A dictionary mapping hook name to a list of callables for branch hooks.
1749
 
 
1750
 
    e.g. ['post_push'] Is the list of items to be called when the
1751
 
    push function is invoked.
1752
 
    """
1753
 
 
1754
 
    def __init__(self):
1755
 
        """Create the default hooks.
1756
 
 
1757
 
        These are all empty initially, because by default nothing should get
1758
 
        notified.
1759
 
        """
1760
 
        Hooks.__init__(self, "bzrlib.branch", "Branch.hooks")
1761
 
        self.add_hook('open',
1762
 
            "Called with the Branch object that has been opened after a "
1763
 
            "branch is opened.", (1, 8))
1764
 
        self.add_hook('post_push',
1765
 
            "Called after a push operation completes. post_push is called "
1766
 
            "with a bzrlib.branch.BranchPushResult object and only runs in the "
1767
 
            "bzr client.", (0, 15))
1768
 
        self.add_hook('post_pull',
1769
 
            "Called after a pull operation completes. post_pull is called "
1770
 
            "with a bzrlib.branch.PullResult object and only runs in the "
1771
 
            "bzr client.", (0, 15))
1772
 
        self.add_hook('pre_commit',
1773
 
            "Called after a commit is calculated but before it is "
1774
 
            "completed. pre_commit is called with (local, master, old_revno, "
1775
 
            "old_revid, future_revno, future_revid, tree_delta, future_tree"
1776
 
            "). old_revid is NULL_REVISION for the first commit to a branch, "
1777
 
            "tree_delta is a TreeDelta object describing changes from the "
1778
 
            "basis revision. hooks MUST NOT modify this delta. "
1779
 
            " future_tree is an in-memory tree obtained from "
1780
 
            "CommitBuilder.revision_tree() and hooks MUST NOT modify this "
1781
 
            "tree.", (0,91))
1782
 
        self.add_hook('post_commit',
1783
 
            "Called in the bzr client after a commit has completed. "
1784
 
            "post_commit is called with (local, master, old_revno, old_revid, "
1785
 
            "new_revno, new_revid). old_revid is NULL_REVISION for the first "
1786
 
            "commit to a branch.", (0, 15))
1787
 
        self.add_hook('post_uncommit',
1788
 
            "Called in the bzr client after an uncommit completes. "
1789
 
            "post_uncommit is called with (local, master, old_revno, "
1790
 
            "old_revid, new_revno, new_revid) where local is the local branch "
1791
 
            "or None, master is the target branch, and an empty branch "
1792
 
            "receives new_revno of 0, new_revid of None.", (0, 15))
1793
 
        self.add_hook('pre_change_branch_tip',
1794
 
            "Called in bzr client and server before a change to the tip of a "
1795
 
            "branch is made. pre_change_branch_tip is called with a "
1796
 
            "bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1797
 
            "commit, uncommit will all trigger this hook.", (1, 6))
1798
 
        self.add_hook('post_change_branch_tip',
1799
 
            "Called in bzr client and server after a change to the tip of a "
1800
 
            "branch is made. post_change_branch_tip is called with a "
1801
 
            "bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1802
 
            "commit, uncommit will all trigger this hook.", (1, 4))
1803
 
        self.add_hook('transform_fallback_location',
1804
 
            "Called when a stacked branch is activating its fallback "
1805
 
            "locations. transform_fallback_location is called with (branch, "
1806
 
            "url), and should return a new url. Returning the same url "
1807
 
            "allows it to be used as-is, returning a different one can be "
1808
 
            "used to cause the branch to stack on a closer copy of that "
1809
 
            "fallback_location. Note that the branch cannot have history "
1810
 
            "accessing methods called on it during this hook because the "
1811
 
            "fallback locations have not been activated. When there are "
1812
 
            "multiple hooks installed for transform_fallback_location, "
1813
 
            "all are called with the url returned from the previous hook."
1814
 
            "The order is however undefined.", (1, 9))
1815
 
        self.add_hook('automatic_tag_name',
1816
 
            "Called to determine an automatic tag name for a revision. "
1817
 
            "automatic_tag_name is called with (branch, revision_id) and "
1818
 
            "should return a tag name or None if no tag name could be "
1819
 
            "determined. The first non-None tag name returned will be used.",
1820
 
            (2, 2))
1821
 
        self.add_hook('post_branch_init',
1822
 
            "Called after new branch initialization completes. "
1823
 
            "post_branch_init is called with a "
1824
 
            "bzrlib.branch.BranchInitHookParams. "
1825
 
            "Note that init, branch and checkout (both heavyweight and "
1826
 
            "lightweight) will all trigger this hook.", (2, 2))
1827
 
        self.add_hook('post_switch',
1828
 
            "Called after a checkout switches branch. "
1829
 
            "post_switch is called with a "
1830
 
            "bzrlib.branch.SwitchHookParams.", (2, 2))
1831
 
 
1832
 
 
1833
 
 
1834
 
# install the default hooks into the Branch class.
1835
 
Branch.hooks = BranchHooks()
1836
 
 
1837
 
 
1838
 
class ChangeBranchTipParams(object):
1839
 
    """Object holding parameters passed to `*_change_branch_tip` hooks.
1840
 
 
1841
 
    There are 5 fields that hooks may wish to access:
1842
 
 
1843
 
    :ivar branch: the branch being changed
1844
 
    :ivar old_revno: revision number before the change
1845
 
    :ivar new_revno: revision number after the change
1846
 
    :ivar old_revid: revision id before the change
1847
 
    :ivar new_revid: revision id after the change
1848
 
 
1849
 
    The revid fields are strings. The revno fields are integers.
1850
 
    """
1851
 
 
1852
 
    def __init__(self, branch, old_revno, new_revno, old_revid, new_revid):
1853
 
        """Create a group of ChangeBranchTip parameters.
1854
 
 
1855
 
        :param branch: The branch being changed.
1856
 
        :param old_revno: Revision number before the change.
1857
 
        :param new_revno: Revision number after the change.
1858
 
        :param old_revid: Tip revision id before the change.
1859
 
        :param new_revid: Tip revision id after the change.
1860
 
        """
1861
 
        self.branch = branch
1862
 
        self.old_revno = old_revno
1863
 
        self.new_revno = new_revno
1864
 
        self.old_revid = old_revid
1865
 
        self.new_revid = new_revid
1866
 
 
1867
 
    def __eq__(self, other):
1868
 
        return self.__dict__ == other.__dict__
1869
 
 
1870
 
    def __repr__(self):
1871
 
        return "<%s of %s from (%s, %s) to (%s, %s)>" % (
1872
 
            self.__class__.__name__, self.branch,
1873
 
            self.old_revno, self.old_revid, self.new_revno, self.new_revid)
1874
 
 
1875
 
 
1876
 
class BranchInitHookParams(object):
1877
 
    """Object holding parameters passed to `*_branch_init` hooks.
1878
 
 
1879
 
    There are 4 fields that hooks may wish to access:
1880
 
 
1881
 
    :ivar format: the branch format
1882
 
    :ivar bzrdir: the ControlDir where the branch will be/has been initialized
1883
 
    :ivar name: name of colocated branch, if any (or None)
1884
 
    :ivar branch: the branch created
1885
 
 
1886
 
    Note that for lightweight checkouts, the bzrdir and format fields refer to
1887
 
    the checkout, hence they are different from the corresponding fields in
1888
 
    branch, which refer to the original branch.
1889
 
    """
1890
 
 
1891
 
    def __init__(self, format, controldir, name, branch):
1892
 
        """Create a group of BranchInitHook parameters.
1893
 
 
1894
 
        :param format: the branch format
1895
 
        :param controldir: the ControlDir where the branch will be/has been
1896
 
            initialized
1897
 
        :param name: name of colocated branch, if any (or None)
1898
 
        :param branch: the branch created
1899
 
 
1900
 
        Note that for lightweight checkouts, the bzrdir and format fields refer
1901
 
        to the checkout, hence they are different from the corresponding fields
1902
 
        in branch, which refer to the original branch.
1903
 
        """
1904
 
        self.format = format
1905
 
        self.bzrdir = controldir
1906
 
        self.name = name
1907
 
        self.branch = branch
1908
 
 
1909
 
    def __eq__(self, other):
1910
 
        return self.__dict__ == other.__dict__
1911
 
 
1912
 
    def __repr__(self):
1913
 
        return "<%s of %s>" % (self.__class__.__name__, self.branch)
1914
 
 
1915
 
 
1916
 
class SwitchHookParams(object):
1917
 
    """Object holding parameters passed to `*_switch` hooks.
1918
 
 
1919
 
    There are 4 fields that hooks may wish to access:
1920
 
 
1921
 
    :ivar control_dir: ControlDir of the checkout to change
1922
 
    :ivar to_branch: branch that the checkout is to reference
1923
 
    :ivar force: skip the check for local commits in a heavy checkout
1924
 
    :ivar revision_id: revision ID to switch to (or None)
1925
 
    """
1926
 
 
1927
 
    def __init__(self, control_dir, to_branch, force, revision_id):
1928
 
        """Create a group of SwitchHook parameters.
1929
 
 
1930
 
        :param control_dir: ControlDir of the checkout to change
1931
 
        :param to_branch: branch that the checkout is to reference
1932
 
        :param force: skip the check for local commits in a heavy checkout
1933
 
        :param revision_id: revision ID to switch to (or None)
1934
 
        """
1935
 
        self.control_dir = control_dir
1936
 
        self.to_branch = to_branch
1937
 
        self.force = force
1938
 
        self.revision_id = revision_id
1939
 
 
1940
 
    def __eq__(self, other):
1941
 
        return self.__dict__ == other.__dict__
1942
 
 
1943
 
    def __repr__(self):
1944
 
        return "<%s for %s to (%s, %s)>" % (self.__class__.__name__,
1945
 
            self.control_dir, self.to_branch,
1946
 
            self.revision_id)
1947
 
 
1948
 
 
1949
 
class BranchFormatMetadir(bzrdir.BzrFormat, BranchFormat):
1950
 
    """Base class for branch formats that live in meta directories.
1951
 
    """
1952
 
 
1953
 
    def __init__(self):
1954
 
        BranchFormat.__init__(self)
1955
 
        bzrdir.BzrFormat.__init__(self)
1956
 
 
1957
 
    @classmethod
1958
 
    def find_format(klass, controldir, name=None):
1959
 
        """Return the format for the branch object in controldir."""
1960
 
        try:
1961
 
            transport = controldir.get_branch_transport(None, name=name)
1962
 
        except errors.NoSuchFile:
1963
 
            raise errors.NotBranchError(path=name, bzrdir=controldir)
1964
 
        try:
1965
 
            format_string = transport.get_bytes("format")
1966
 
        except errors.NoSuchFile:
1967
 
            raise errors.NotBranchError(path=transport.base, bzrdir=controldir)
1968
 
        return klass._find_format(format_registry, 'branch', format_string)
1969
 
 
1970
 
    def _branch_class(self):
1971
 
        """What class to instantiate on open calls."""
1972
 
        raise NotImplementedError(self._branch_class)
1973
 
 
1974
 
    def _get_initial_config(self, append_revisions_only=None):
1975
 
        if append_revisions_only:
1976
 
            return "append_revisions_only = True\n"
1977
 
        else:
1978
 
            # Avoid writing anything if append_revisions_only is disabled,
1979
 
            # as that is the default.
1980
 
            return ""
1981
 
 
1982
 
    def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
1983
 
                           repository=None):
1984
 
        """Initialize a branch in a control dir, with specified files
1985
 
 
1986
 
        :param a_bzrdir: The bzrdir to initialize the branch in
1987
 
        :param utf8_files: The files to create as a list of
1988
 
            (filename, content) tuples
1989
 
        :param name: Name of colocated branch to create, if any
1990
 
        :return: a branch in this format
1991
 
        """
1992
 
        if name is None:
1993
 
            name = a_bzrdir._get_selected_branch()
1994
 
        mutter('creating branch %r in %s', self, a_bzrdir.user_url)
1995
 
        branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1996
 
        control_files = lockable_files.LockableFiles(branch_transport,
1997
 
            'lock', lockdir.LockDir)
 
766
        """See BranchFormat.get_format_string()."""
 
767
        return "Bazaar-NG branch format 5\n"
 
768
 
 
769
    def get_format_description(self):
 
770
        """See BranchFormat.get_format_description()."""
 
771
        return "Branch format 5"
 
772
        
 
773
    def initialize(self, a_bzrdir):
 
774
        """Create a branch of this format in a_bzrdir."""
 
775
        mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
 
776
        branch_transport = a_bzrdir.get_branch_transport(self)
 
777
        utf8_files = [('revision-history', ''),
 
778
                      ('branch-name', ''),
 
779
                      ]
 
780
        control_files = LockableFiles(branch_transport, 'lock', lockdir.LockDir)
1998
781
        control_files.create_lock()
1999
782
        control_files.lock_write()
 
783
        control_files.put_utf8('format', self.get_format_string())
2000
784
        try:
2001
 
            utf8_files += [('format', self.as_string())]
2002
 
            for (filename, content) in utf8_files:
2003
 
                branch_transport.put_bytes(
2004
 
                    filename, content,
2005
 
                    mode=a_bzrdir._get_file_mode())
 
785
            for file, content in utf8_files:
 
786
                control_files.put_utf8(file, content)
2006
787
        finally:
2007
788
            control_files.unlock()
2008
 
        branch = self.open(a_bzrdir, name, _found=True,
2009
 
                found_repository=repository)
2010
 
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2011
 
        return branch
2012
 
 
2013
 
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False,
2014
 
            found_repository=None, possible_transports=None):
2015
 
        """See BranchFormat.open()."""
2016
 
        if name is None:
2017
 
            name = a_bzrdir._get_selected_branch()
 
789
        return self.open(a_bzrdir, _found=True, )
 
790
 
 
791
    def __init__(self):
 
792
        super(BzrBranchFormat5, self).__init__()
 
793
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
 
794
 
 
795
    def open(self, a_bzrdir, _found=False):
 
796
        """Return the branch object for a_bzrdir
 
797
 
 
798
        _found is a private parameter, do not use it. It is used to indicate
 
799
               if format probing has already be done.
 
800
        """
2018
801
        if not _found:
2019
 
            format = BranchFormatMetadir.find_format(a_bzrdir, name=name)
2020
 
            if format.__class__ != self.__class__:
2021
 
                raise AssertionError("wrong format %r found for %r" %
2022
 
                    (format, self))
2023
 
        transport = a_bzrdir.get_branch_transport(None, name=name)
2024
 
        try:
2025
 
            control_files = lockable_files.LockableFiles(transport, 'lock',
2026
 
                                                         lockdir.LockDir)
2027
 
            if found_repository is None:
2028
 
                found_repository = a_bzrdir.find_repository()
2029
 
            return self._branch_class()(_format=self,
2030
 
                              _control_files=control_files,
2031
 
                              name=name,
2032
 
                              a_bzrdir=a_bzrdir,
2033
 
                              _repository=found_repository,
2034
 
                              ignore_fallbacks=ignore_fallbacks,
2035
 
                              possible_transports=possible_transports)
2036
 
        except errors.NoSuchFile:
2037
 
            raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
2038
 
 
2039
 
    @property
2040
 
    def _matchingbzrdir(self):
2041
 
        ret = bzrdir.BzrDirMetaFormat1()
2042
 
        ret.set_branch_format(self)
2043
 
        return ret
2044
 
 
2045
 
    def supports_tags(self):
2046
 
        return True
2047
 
 
2048
 
    def supports_leaving_lock(self):
2049
 
        return True
2050
 
 
2051
 
    def check_support_status(self, allow_unsupported, recommend_upgrade=True,
2052
 
            basedir=None):
2053
 
        BranchFormat.check_support_status(self,
2054
 
            allow_unsupported=allow_unsupported, recommend_upgrade=recommend_upgrade,
2055
 
            basedir=basedir)
2056
 
        bzrdir.BzrFormat.check_support_status(self, allow_unsupported=allow_unsupported,
2057
 
            recommend_upgrade=recommend_upgrade, basedir=basedir)
2058
 
 
2059
 
 
2060
 
class BzrBranchFormat6(BranchFormatMetadir):
2061
 
    """Branch format with last-revision and tags.
2062
 
 
2063
 
    Unlike previous formats, this has no explicit revision history. Instead,
2064
 
    this just stores the last-revision, and the left-hand history leading
2065
 
    up to there is the history.
2066
 
 
2067
 
    This format was introduced in bzr 0.15
2068
 
    and became the default in 0.91.
2069
 
    """
2070
 
 
2071
 
    def _branch_class(self):
2072
 
        return BzrBranch6
2073
 
 
2074
 
    @classmethod
2075
 
    def get_format_string(cls):
2076
 
        """See BranchFormat.get_format_string()."""
2077
 
        return "Bazaar Branch Format 6 (bzr 0.15)\n"
2078
 
 
2079
 
    def get_format_description(self):
2080
 
        """See BranchFormat.get_format_description()."""
2081
 
        return "Branch format 6"
2082
 
 
2083
 
    def initialize(self, a_bzrdir, name=None, repository=None,
2084
 
                   append_revisions_only=None):
2085
 
        """Create a branch of this format in a_bzrdir."""
2086
 
        utf8_files = [('last-revision', '0 null:\n'),
2087
 
                      ('branch.conf',
2088
 
                          self._get_initial_config(append_revisions_only)),
2089
 
                      ('tags', ''),
2090
 
                      ]
2091
 
        return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2092
 
 
2093
 
    def make_tags(self, branch):
2094
 
        """See bzrlib.branch.BranchFormat.make_tags()."""
2095
 
        return _mod_tag.BasicTags(branch)
2096
 
 
2097
 
    def supports_set_append_revisions_only(self):
2098
 
        return True
2099
 
 
2100
 
 
2101
 
class BzrBranchFormat8(BranchFormatMetadir):
2102
 
    """Metadir format supporting storing locations of subtree branches."""
2103
 
 
2104
 
    def _branch_class(self):
2105
 
        return BzrBranch8
2106
 
 
2107
 
    @classmethod
2108
 
    def get_format_string(cls):
2109
 
        """See BranchFormat.get_format_string()."""
2110
 
        return "Bazaar Branch Format 8 (needs bzr 1.15)\n"
2111
 
 
2112
 
    def get_format_description(self):
2113
 
        """See BranchFormat.get_format_description()."""
2114
 
        return "Branch format 8"
2115
 
 
2116
 
    def initialize(self, a_bzrdir, name=None, repository=None,
2117
 
                   append_revisions_only=None):
2118
 
        """Create a branch of this format in a_bzrdir."""
2119
 
        utf8_files = [('last-revision', '0 null:\n'),
2120
 
                      ('branch.conf',
2121
 
                          self._get_initial_config(append_revisions_only)),
2122
 
                      ('tags', ''),
2123
 
                      ('references', '')
2124
 
                      ]
2125
 
        return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2126
 
 
2127
 
    def make_tags(self, branch):
2128
 
        """See bzrlib.branch.BranchFormat.make_tags()."""
2129
 
        return _mod_tag.BasicTags(branch)
2130
 
 
2131
 
    def supports_set_append_revisions_only(self):
2132
 
        return True
2133
 
 
2134
 
    def supports_stacking(self):
2135
 
        return True
2136
 
 
2137
 
    supports_reference_locations = True
2138
 
 
2139
 
 
2140
 
class BzrBranchFormat7(BranchFormatMetadir):
2141
 
    """Branch format with last-revision, tags, and a stacked location pointer.
2142
 
 
2143
 
    The stacked location pointer is passed down to the repository and requires
2144
 
    a repository format with supports_external_lookups = True.
2145
 
 
2146
 
    This format was introduced in bzr 1.6.
2147
 
    """
2148
 
 
2149
 
    def initialize(self, a_bzrdir, name=None, repository=None,
2150
 
                   append_revisions_only=None):
2151
 
        """Create a branch of this format in a_bzrdir."""
2152
 
        utf8_files = [('last-revision', '0 null:\n'),
2153
 
                      ('branch.conf',
2154
 
                          self._get_initial_config(append_revisions_only)),
2155
 
                      ('tags', ''),
2156
 
                      ]
2157
 
        return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2158
 
 
2159
 
    def _branch_class(self):
2160
 
        return BzrBranch7
2161
 
 
2162
 
    @classmethod
2163
 
    def get_format_string(cls):
2164
 
        """See BranchFormat.get_format_string()."""
2165
 
        return "Bazaar Branch Format 7 (needs bzr 1.6)\n"
2166
 
 
2167
 
    def get_format_description(self):
2168
 
        """See BranchFormat.get_format_description()."""
2169
 
        return "Branch format 7"
2170
 
 
2171
 
    def supports_set_append_revisions_only(self):
2172
 
        return True
2173
 
 
2174
 
    def supports_stacking(self):
2175
 
        return True
2176
 
 
2177
 
    def make_tags(self, branch):
2178
 
        """See bzrlib.branch.BranchFormat.make_tags()."""
2179
 
        return _mod_tag.BasicTags(branch)
2180
 
 
2181
 
    supports_reference_locations = False
2182
 
 
2183
 
 
2184
 
class BranchReferenceFormat(BranchFormatMetadir):
 
802
            format = BranchFormat.find_format(a_bzrdir)
 
803
            assert format.__class__ == self.__class__
 
804
        transport = a_bzrdir.get_branch_transport(None)
 
805
        control_files = LockableFiles(transport, 'lock', lockdir.LockDir)
 
806
        return BzrBranch5(_format=self,
 
807
                          _control_files=control_files,
 
808
                          a_bzrdir=a_bzrdir,
 
809
                          _repository=a_bzrdir.find_repository())
 
810
 
 
811
    def __str__(self):
 
812
        return "Bazaar-NG Metadir branch format 5"
 
813
 
 
814
 
 
815
class BranchReferenceFormat(BranchFormat):
2185
816
    """Bzr branch reference format.
2186
817
 
2187
818
    Branch references are used in implementing checkouts, they
2192
823
     - a format string
2193
824
    """
2194
825
 
2195
 
    @classmethod
2196
 
    def get_format_string(cls):
 
826
    def get_format_string(self):
2197
827
        """See BranchFormat.get_format_string()."""
2198
828
        return "Bazaar-NG Branch Reference Format 1\n"
2199
829
 
2200
830
    def get_format_description(self):
2201
831
        """See BranchFormat.get_format_description()."""
2202
832
        return "Checkout reference format 1"
2203
 
 
2204
 
    def get_reference(self, a_bzrdir, name=None):
2205
 
        """See BranchFormat.get_reference()."""
2206
 
        transport = a_bzrdir.get_branch_transport(None, name=name)
2207
 
        return transport.get_bytes('location')
2208
 
 
2209
 
    def set_reference(self, a_bzrdir, name, to_branch):
2210
 
        """See BranchFormat.set_reference()."""
2211
 
        transport = a_bzrdir.get_branch_transport(None, name=name)
2212
 
        location = transport.put_bytes('location', to_branch.base)
2213
 
 
2214
 
    def initialize(self, a_bzrdir, name=None, target_branch=None,
2215
 
            repository=None, append_revisions_only=None):
 
833
        
 
834
    def initialize(self, a_bzrdir, target_branch=None):
2216
835
        """Create a branch of this format in a_bzrdir."""
2217
836
        if target_branch is None:
2218
837
            # this format does not implement branch itself, thus the implicit
2219
838
            # creation contract must see it as uninitializable
2220
839
            raise errors.UninitializableFormat(self)
2221
 
        mutter('creating branch reference in %s', a_bzrdir.user_url)
2222
 
        if a_bzrdir._format.fixed_components:
2223
 
            raise errors.IncompatibleFormat(self, a_bzrdir._format)
2224
 
        if name is None:
2225
 
            name = a_bzrdir._get_selected_branch()
2226
 
        branch_transport = a_bzrdir.get_branch_transport(self, name=name)
2227
 
        branch_transport.put_bytes('location',
2228
 
            target_branch.user_url)
2229
 
        branch_transport.put_bytes('format', self.as_string())
2230
 
        branch = self.open(a_bzrdir, name, _found=True,
2231
 
            possible_transports=[target_branch.bzrdir.root_transport])
2232
 
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2233
 
        return branch
 
840
        mutter('creating branch reference in %s', a_bzrdir.transport.base)
 
841
        branch_transport = a_bzrdir.get_branch_transport(self)
 
842
        # FIXME rbc 20060209 one j-a-ms encoding branch lands this str() cast is not needed.
 
843
        branch_transport.put('location', StringIO(str(target_branch.bzrdir.root_transport.base)))
 
844
        branch_transport.put('format', StringIO(self.get_format_string()))
 
845
        return self.open(a_bzrdir, _found=True)
 
846
 
 
847
    def __init__(self):
 
848
        super(BranchReferenceFormat, self).__init__()
 
849
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
2234
850
 
2235
851
    def _make_reference_clone_function(format, a_branch):
2236
852
        """Create a clone() routine for a branch dynamically."""
2237
 
        def clone(to_bzrdir, revision_id=None,
2238
 
            repository_policy=None):
 
853
        def clone(to_bzrdir, revision_id=None):
2239
854
            """See Branch.clone()."""
2240
 
            return format.initialize(to_bzrdir, target_branch=a_branch)
 
855
            return format.initialize(to_bzrdir, a_branch)
2241
856
            # cannot obey revision_id limits when cloning a reference ...
2242
857
            # FIXME RBC 20060210 either nuke revision_id for clone, or
2243
858
            # emit some sort of warning/error to the caller ?!
2244
859
        return clone
2245
860
 
2246
 
    def open(self, a_bzrdir, name=None, _found=False, location=None,
2247
 
             possible_transports=None, ignore_fallbacks=False,
2248
 
             found_repository=None):
 
861
    def open(self, a_bzrdir, _found=False):
2249
862
        """Return the branch that the branch reference in a_bzrdir points at.
2250
863
 
2251
 
        :param a_bzrdir: A BzrDir that contains a branch.
2252
 
        :param name: Name of colocated branch to open, if any
2253
 
        :param _found: a private parameter, do not use it. It is used to
2254
 
            indicate if format probing has already be done.
2255
 
        :param ignore_fallbacks: when set, no fallback branches will be opened
2256
 
            (if there are any).  Default is to open fallbacks.
2257
 
        :param location: The location of the referenced branch.  If
2258
 
            unspecified, this will be determined from the branch reference in
2259
 
            a_bzrdir.
2260
 
        :param possible_transports: An optional reusable transports list.
 
864
        _found is a private parameter, do not use it. It is used to indicate
 
865
               if format probing has already be done.
2261
866
        """
2262
 
        if name is None:
2263
 
            name = a_bzrdir._get_selected_branch()
2264
867
        if not _found:
2265
 
            format = BranchFormatMetadir.find_format(a_bzrdir, name=name)
2266
 
            if format.__class__ != self.__class__:
2267
 
                raise AssertionError("wrong format %r found for %r" %
2268
 
                    (format, self))
2269
 
        if location is None:
2270
 
            location = self.get_reference(a_bzrdir, name)
2271
 
        real_bzrdir = controldir.ControlDir.open(
2272
 
            location, possible_transports=possible_transports)
2273
 
        result = real_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks,
2274
 
            possible_transports=possible_transports)
 
868
            format = BranchFormat.find_format(a_bzrdir)
 
869
            assert format.__class__ == self.__class__
 
870
        transport = a_bzrdir.get_branch_transport(None)
 
871
        real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
 
872
        result = real_bzrdir.open_branch()
2275
873
        # this changes the behaviour of result.clone to create a new reference
2276
874
        # rather than a copy of the content of the branch.
2277
875
        # I did not use a proxy object because that needs much more extensive
2284
882
        return result
2285
883
 
2286
884
 
2287
 
class BranchFormatRegistry(controldir.ControlComponentFormatRegistry):
2288
 
    """Branch format registry."""
2289
 
 
2290
 
    def __init__(self, other_registry=None):
2291
 
        super(BranchFormatRegistry, self).__init__(other_registry)
2292
 
        self._default_format = None
2293
 
 
2294
 
    def set_default(self, format):
2295
 
        self._default_format = format
2296
 
 
2297
 
    def get_default(self):
2298
 
        return self._default_format
2299
 
 
2300
 
 
2301
 
network_format_registry = registry.FormatRegistry()
2302
 
"""Registry of formats indexed by their network name.
2303
 
 
2304
 
The network name for a branch format is an identifier that can be used when
2305
 
referring to formats with smart server operations. See
2306
 
BranchFormat.network_name() for more detail.
2307
 
"""
2308
 
 
2309
 
format_registry = BranchFormatRegistry(network_format_registry)
2310
 
 
2311
 
 
2312
885
# formats which have no format string are not discoverable
2313
886
# and not independently creatable, so are not registered.
2314
 
__format6 = BzrBranchFormat6()
2315
 
__format7 = BzrBranchFormat7()
2316
 
__format8 = BzrBranchFormat8()
2317
 
format_registry.register_lazy(
2318
 
    "Bazaar-NG branch format 5\n", "bzrlib.branchfmt.fullhistory", "BzrBranchFormat5")
2319
 
format_registry.register(BranchReferenceFormat())
2320
 
format_registry.register(__format6)
2321
 
format_registry.register(__format7)
2322
 
format_registry.register(__format8)
2323
 
format_registry.set_default(__format7)
2324
 
 
2325
 
 
2326
 
class BranchWriteLockResult(LogicalLockResult):
2327
 
    """The result of write locking a branch.
2328
 
 
2329
 
    :ivar branch_token: The token obtained from the underlying branch lock, or
2330
 
        None.
2331
 
    :ivar unlock: A callable which will unlock the lock.
2332
 
    """
2333
 
 
2334
 
    def __init__(self, unlock, branch_token):
2335
 
        LogicalLockResult.__init__(self, unlock)
2336
 
        self.branch_token = branch_token
2337
 
 
2338
 
    def __repr__(self):
2339
 
        return "BranchWriteLockResult(%s, %s)" % (self.branch_token,
2340
 
            self.unlock)
2341
 
 
2342
 
 
2343
 
class BzrBranch(Branch, _RelockDebugMixin):
 
887
__default_format = BzrBranchFormat5()
 
888
BranchFormat.register_format(__default_format)
 
889
BranchFormat.register_format(BranchReferenceFormat())
 
890
BranchFormat.set_default_format(__default_format)
 
891
_legacy_formats = [BzrBranchFormat4(),
 
892
                   ]
 
893
 
 
894
class BzrBranch(Branch):
2344
895
    """A branch stored in the actual filesystem.
2345
896
 
2346
897
    Note that it's "local" in the context of the filesystem; it doesn't
2347
898
    really matter if it's on an nfs/smb/afs/coda/... share, as long as
2348
899
    it's writable, and can be accessed via the normal filesystem API.
2349
 
 
2350
 
    :ivar _transport: Transport for file operations on this branch's
2351
 
        control files, typically pointing to the .bzr/branch directory.
2352
 
    :ivar repository: Repository for this branch.
2353
 
    :ivar base: The url of the base directory for this branch; the one
2354
 
        containing the .bzr directory.
2355
 
    :ivar name: Optional colocated branch name as it exists in the control
2356
 
        directory.
2357
900
    """
2358
 
 
2359
 
    def __init__(self, _format=None,
2360
 
                 _control_files=None, a_bzrdir=None, name=None,
2361
 
                 _repository=None, ignore_fallbacks=False,
2362
 
                 possible_transports=None):
2363
 
        """Create new branch object at a particular location."""
 
901
    
 
902
    def __init__(self, transport=DEPRECATED_PARAMETER, init=DEPRECATED_PARAMETER,
 
903
                 relax_version_check=DEPRECATED_PARAMETER, _format=None,
 
904
                 _control_files=None, a_bzrdir=None, _repository=None):
 
905
        """Create new branch object at a particular location.
 
906
 
 
907
        transport -- A Transport object, defining how to access files.
 
908
        
 
909
        init -- If True, create new control files in a previously
 
910
             unversioned directory.  If False, the branch must already
 
911
             be versioned.
 
912
 
 
913
        relax_version_check -- If true, the usual check for the branch
 
914
            version is not applied.  This is intended only for
 
915
            upgrade/recovery type use; it's not guaranteed that
 
916
            all operations will work on old format branches.
 
917
        """
2364
918
        if a_bzrdir is None:
2365
 
            raise ValueError('a_bzrdir must be supplied')
2366
 
        if name is None:
2367
 
            raise ValueError('name must be supplied')
2368
 
        self.bzrdir = a_bzrdir
2369
 
        self._user_transport = self.bzrdir.transport.clone('..')
2370
 
        if name != "":
2371
 
            self._user_transport.set_segment_parameter(
2372
 
                "branch", urlutils.escape(name))
2373
 
        self._base = self._user_transport.base
2374
 
        self.name = name
 
919
            self.bzrdir = bzrdir.BzrDir.open(transport.base)
 
920
        else:
 
921
            self.bzrdir = a_bzrdir
 
922
        self._transport = self.bzrdir.transport.clone('..')
 
923
        self._base = self._transport.base
2375
924
        self._format = _format
2376
925
        if _control_files is None:
2377
926
            raise ValueError('BzrBranch _control_files is None')
2378
927
        self.control_files = _control_files
2379
 
        self._transport = _control_files._transport
 
928
        if deprecated_passed(init):
 
929
            warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
 
930
                 "deprecated as of bzr 0.8. Please use Branch.create().",
 
931
                 DeprecationWarning,
 
932
                 stacklevel=2)
 
933
            if init:
 
934
                # this is slower than before deprecation, oh well never mind.
 
935
                # -> its deprecated.
 
936
                self._initialize(transport.base)
 
937
        self._check_format(_format)
 
938
        if deprecated_passed(relax_version_check):
 
939
            warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
 
940
                 "relax_version_check parameter is deprecated as of bzr 0.8. "
 
941
                 "Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
 
942
                 "open() method.",
 
943
                 DeprecationWarning,
 
944
                 stacklevel=2)
 
945
            if (not relax_version_check
 
946
                and not self._format.is_supported()):
 
947
                raise errors.UnsupportedFormatError(format=fmt)
 
948
        if deprecated_passed(transport):
 
949
            warn("BzrBranch.__init__(transport=XXX...): The transport "
 
950
                 "parameter is deprecated as of bzr 0.8. "
 
951
                 "Please use Branch.open, or bzrdir.open_branch().",
 
952
                 DeprecationWarning,
 
953
                 stacklevel=2)
2380
954
        self.repository = _repository
2381
 
        self.conf_store = None
2382
 
        Branch.__init__(self, possible_transports)
2383
955
 
2384
956
    def __str__(self):
2385
 
        return '%s(%s)' % (self.__class__.__name__, self.user_url)
 
957
        return '%s(%r)' % (self.__class__.__name__, self.base)
2386
958
 
2387
959
    __repr__ = __str__
2388
960
 
 
961
    def __del__(self):
 
962
        # TODO: It might be best to do this somewhere else,
 
963
        # but it is nice for a Branch object to automatically
 
964
        # cache it's information.
 
965
        # Alternatively, we could have the Transport objects cache requests
 
966
        # See the earlier discussion about how major objects (like Branch)
 
967
        # should never expect their __del__ function to run.
 
968
        # XXX: cache_root seems to be unused, 2006-01-13 mbp
 
969
        if hasattr(self, 'cache_root') and self.cache_root is not None:
 
970
            try:
 
971
                osutils.rmtree(self.cache_root)
 
972
            except:
 
973
                pass
 
974
            self.cache_root = None
 
975
 
2389
976
    def _get_base(self):
2390
 
        """Returns the directory containing the control directory."""
2391
977
        return self._base
2392
978
 
2393
979
    base = property(_get_base, doc="The URL for the root of this branch.")
2394
980
 
2395
 
    @property
2396
 
    def user_transport(self):
2397
 
        return self._user_transport
2398
 
 
2399
 
    def _get_config(self):
2400
 
        return _mod_config.TransportConfig(self._transport, 'branch.conf')
2401
 
 
2402
 
    def _get_config_store(self):
2403
 
        if self.conf_store is None:
2404
 
            self.conf_store =  _mod_config.BranchStore(self)
2405
 
        return self.conf_store
2406
 
 
2407
 
    def _uncommitted_branch(self):
2408
 
        """Return the branch that may contain uncommitted changes."""
2409
 
        master = self.get_master_branch()
2410
 
        if master is not None:
2411
 
            return master
2412
 
        else:
2413
 
            return self
2414
 
 
2415
 
    def store_uncommitted(self, creator):
2416
 
        """Store uncommitted changes from a ShelfCreator.
2417
 
 
2418
 
        :param creator: The ShelfCreator containing uncommitted changes, or
2419
 
            None to delete any stored changes.
2420
 
        :raises: ChangesAlreadyStored if the branch already has changes.
2421
 
        """
2422
 
        branch = self._uncommitted_branch()
2423
 
        if creator is None:
2424
 
            branch._transport.delete('stored-transform')
2425
 
            return
2426
 
        if branch._transport.has('stored-transform'):
2427
 
            raise errors.ChangesAlreadyStored
2428
 
        transform = StringIO()
2429
 
        creator.write_shelf(transform)
2430
 
        transform.seek(0)
2431
 
        branch._transport.put_file('stored-transform', transform)
2432
 
 
2433
 
    def get_unshelver(self, tree):
2434
 
        """Return a shelf.Unshelver for this branch and tree.
2435
 
 
2436
 
        :param tree: The tree to use to construct the Unshelver.
2437
 
        :return: an Unshelver or None if no changes are stored.
2438
 
        """
2439
 
        branch = self._uncommitted_branch()
2440
 
        try:
2441
 
            transform = branch._transport.get('stored-transform')
2442
 
        except errors.NoSuchFile:
2443
 
            return None
2444
 
        return shelf.Unshelver.from_tree_and_shelf(tree, transform)
 
981
    def _finish_transaction(self):
 
982
        """Exit the current transaction."""
 
983
        return self.control_files._finish_transaction()
 
984
 
 
985
    def get_transaction(self):
 
986
        """Return the current active transaction.
 
987
 
 
988
        If no transaction is active, this returns a passthrough object
 
989
        for which all data is immediately flushed and no caching happens.
 
990
        """
 
991
        # this is an explicit function so that we can do tricky stuff
 
992
        # when the storage in rev_storage is elsewhere.
 
993
        # we probably need to hook the two 'lock a location' and 
 
994
        # 'have a transaction' together more delicately, so that
 
995
        # we can have two locks (branch and storage) and one transaction
 
996
        # ... and finishing the transaction unlocks both, but unlocking
 
997
        # does not. - RBC 20051121
 
998
        return self.control_files.get_transaction()
 
999
 
 
1000
    def _set_transaction(self, transaction):
 
1001
        """Set a new active transaction."""
 
1002
        return self.control_files._set_transaction(transaction)
 
1003
 
 
1004
    def abspath(self, name):
 
1005
        """See Branch.abspath."""
 
1006
        return self.control_files._transport.abspath(name)
 
1007
 
 
1008
    def _check_format(self, format):
 
1009
        """Identify the branch format if needed.
 
1010
 
 
1011
        The format is stored as a reference to the format object in
 
1012
        self._format for code that needs to check it later.
 
1013
 
 
1014
        The format parameter is either None or the branch format class
 
1015
        used to open this branch.
 
1016
 
 
1017
        FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
 
1018
        """
 
1019
        if format is None:
 
1020
            format = BranchFormat.find_format(self.bzrdir)
 
1021
        self._format = format
 
1022
        mutter("got branch format %s", self._format)
 
1023
 
 
1024
    @needs_read_lock
 
1025
    def get_root_id(self):
 
1026
        """See Branch.get_root_id."""
 
1027
        tree = self.repository.revision_tree(self.last_revision())
 
1028
        return tree.inventory.root.file_id
2445
1029
 
2446
1030
    def is_locked(self):
2447
1031
        return self.control_files.is_locked()
2448
1032
 
2449
 
    def lock_write(self, token=None):
2450
 
        """Lock the branch for write operations.
2451
 
 
2452
 
        :param token: A token to permit reacquiring a previously held and
2453
 
            preserved lock.
2454
 
        :return: A BranchWriteLockResult.
2455
 
        """
2456
 
        if not self.is_locked():
2457
 
            self._note_lock('w')
2458
 
            self.repository._warn_if_deprecated(self)
2459
 
            self.repository.lock_write()
2460
 
            took_lock = True
2461
 
        else:
2462
 
            took_lock = False
 
1033
    def lock_write(self):
 
1034
        self.repository.lock_write()
2463
1035
        try:
2464
 
            return BranchWriteLockResult(self.unlock,
2465
 
                self.control_files.lock_write(token=token))
 
1036
            self.control_files.lock_write()
2466
1037
        except:
2467
 
            if took_lock:
2468
 
                self.repository.unlock()
 
1038
            self.repository.unlock()
2469
1039
            raise
2470
1040
 
2471
1041
    def lock_read(self):
2472
 
        """Lock the branch for read operations.
2473
 
 
2474
 
        :return: A bzrlib.lock.LogicalLockResult.
2475
 
        """
2476
 
        if not self.is_locked():
2477
 
            self._note_lock('r')
2478
 
            self.repository._warn_if_deprecated(self)
2479
 
            self.repository.lock_read()
2480
 
            took_lock = True
2481
 
        else:
2482
 
            took_lock = False
 
1042
        self.repository.lock_read()
2483
1043
        try:
2484
1044
            self.control_files.lock_read()
2485
 
            return LogicalLockResult(self.unlock)
2486
1045
        except:
2487
 
            if took_lock:
2488
 
                self.repository.unlock()
 
1046
            self.repository.unlock()
2489
1047
            raise
2490
1048
 
2491
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
2492
1049
    def unlock(self):
2493
 
        if self.control_files._lock_count == 1 and self.conf_store is not None:
2494
 
            self.conf_store.save_changes()
 
1050
        # TODO: test for failed two phase locks. This is known broken.
2495
1051
        try:
2496
1052
            self.control_files.unlock()
2497
1053
        finally:
2498
 
            if not self.control_files.is_locked():
2499
 
                self.repository.unlock()
2500
 
                # we just released the lock
2501
 
                self._clear_cached_state()
2502
 
 
 
1054
            self.repository.unlock()
 
1055
        
2503
1056
    def peek_lock_mode(self):
2504
1057
        if self.control_files._lock_count == 0:
2505
1058
            return None
2515
1068
        return self.repository.print_file(file, revision_id)
2516
1069
 
2517
1070
    @needs_write_lock
2518
 
    def set_last_revision_info(self, revno, revision_id):
2519
 
        if not revision_id or not isinstance(revision_id, basestring):
2520
 
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2521
 
        revision_id = _mod_revision.ensure_null(revision_id)
2522
 
        old_revno, old_revid = self.last_revision_info()
2523
 
        if self.get_append_revisions_only():
2524
 
            self._check_history_violation(revision_id)
2525
 
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2526
 
        self._write_last_revision_info(revno, revision_id)
2527
 
        self._clear_cached_state()
2528
 
        self._last_revision_info_cache = revno, revision_id
2529
 
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
 
1071
    def append_revision(self, *revision_ids):
 
1072
        """See Branch.append_revision."""
 
1073
        for revision_id in revision_ids:
 
1074
            mutter("add {%s} to revision-history" % revision_id)
 
1075
        rev_history = self.revision_history()
 
1076
        rev_history.extend(revision_ids)
 
1077
        self.set_revision_history(rev_history)
 
1078
 
 
1079
    @needs_write_lock
 
1080
    def set_revision_history(self, rev_history):
 
1081
        """See Branch.set_revision_history."""
 
1082
        self.control_files.put_utf8(
 
1083
            'revision-history', '\n'.join(rev_history))
 
1084
        transaction = self.get_transaction()
 
1085
        history = transaction.map.find_revision_history()
 
1086
        if history is not None:
 
1087
            # update the revision history in the identity map.
 
1088
            history[:] = list(rev_history)
 
1089
            # this call is disabled because revision_history is 
 
1090
            # not really an object yet, and the transaction is for objects.
 
1091
            # transaction.register_dirty(history)
 
1092
        else:
 
1093
            transaction.map.add_revision_history(rev_history)
 
1094
            # this call is disabled because revision_history is 
 
1095
            # not really an object yet, and the transaction is for objects.
 
1096
            # transaction.register_clean(history)
 
1097
 
 
1098
    @needs_read_lock
 
1099
    def revision_history(self):
 
1100
        """See Branch.revision_history."""
 
1101
        transaction = self.get_transaction()
 
1102
        history = transaction.map.find_revision_history()
 
1103
        if history is not None:
 
1104
            # mutter("cache hit for revision-history in %s", self)
 
1105
            return list(history)
 
1106
        decode_utf8 = cache_utf8.decode
 
1107
        history = [decode_utf8(l.rstrip('\r\n')) for l in
 
1108
                self.control_files.get('revision-history').readlines()]
 
1109
        transaction.map.add_revision_history(history)
 
1110
        # this call is disabled because revision_history is 
 
1111
        # not really an object yet, and the transaction is for objects.
 
1112
        # transaction.register_clean(history, precious=True)
 
1113
        return list(history)
 
1114
 
 
1115
    @needs_write_lock
 
1116
    def generate_revision_history(self, revision_id, last_rev=None, 
 
1117
        other_branch=None):
 
1118
        """Create a new revision history that will finish with revision_id.
 
1119
        
 
1120
        :param revision_id: the new tip to use.
 
1121
        :param last_rev: The previous last_revision. If not None, then this
 
1122
            must be a ancestory of revision_id, or DivergedBranches is raised.
 
1123
        :param other_branch: The other branch that DivergedBranches should
 
1124
            raise with respect to.
 
1125
        """
 
1126
        # stop_revision must be a descendant of last_revision
 
1127
        stop_graph = self.repository.get_revision_graph(revision_id)
 
1128
        if last_rev is not None and last_rev not in stop_graph:
 
1129
            # our previous tip is not merged into stop_revision
 
1130
            raise errors.DivergedBranches(self, other_branch)
 
1131
        # make a new revision history from the graph
 
1132
        current_rev_id = revision_id
 
1133
        new_history = []
 
1134
        while current_rev_id not in (None, revision.NULL_REVISION):
 
1135
            new_history.append(current_rev_id)
 
1136
            current_rev_id_parents = stop_graph[current_rev_id]
 
1137
            try:
 
1138
                current_rev_id = current_rev_id_parents[0]
 
1139
            except IndexError:
 
1140
                current_rev_id = None
 
1141
        new_history.reverse()
 
1142
        self.set_revision_history(new_history)
 
1143
 
 
1144
    @needs_write_lock
 
1145
    def update_revisions(self, other, stop_revision=None):
 
1146
        """See Branch.update_revisions."""
 
1147
        other.lock_read()
 
1148
        try:
 
1149
            if stop_revision is None:
 
1150
                stop_revision = other.last_revision()
 
1151
                if stop_revision is None:
 
1152
                    # if there are no commits, we're done.
 
1153
                    return
 
1154
            # whats the current last revision, before we fetch [and change it
 
1155
            # possibly]
 
1156
            last_rev = self.last_revision()
 
1157
            # we fetch here regardless of whether we need to so that we pickup
 
1158
            # filled in ghosts.
 
1159
            self.fetch(other, stop_revision)
 
1160
            my_ancestry = self.repository.get_ancestry(last_rev)
 
1161
            if stop_revision in my_ancestry:
 
1162
                # last_revision is a descendant of stop_revision
 
1163
                return
 
1164
            self.generate_revision_history(stop_revision, last_rev=last_rev,
 
1165
                other_branch=other)
 
1166
        finally:
 
1167
            other.unlock()
2530
1168
 
2531
1169
    def basis_tree(self):
2532
1170
        """See Branch.basis_tree."""
2533
1171
        return self.repository.revision_tree(self.last_revision())
2534
1172
 
2535
 
    def _get_parent_location(self):
 
1173
    @deprecated_method(zero_eight)
 
1174
    def working_tree(self):
 
1175
        """Create a Working tree object for this branch."""
 
1176
 
 
1177
        from bzrlib.transport.local import LocalTransport
 
1178
        if (self.base.find('://') != -1 or 
 
1179
            not isinstance(self._transport, LocalTransport)):
 
1180
            raise NoWorkingTree(self.base)
 
1181
        return self.bzrdir.open_workingtree()
 
1182
 
 
1183
    @needs_write_lock
 
1184
    def pull(self, source, overwrite=False, stop_revision=None):
 
1185
        """See Branch.pull."""
 
1186
        source.lock_read()
 
1187
        try:
 
1188
            old_count = len(self.revision_history())
 
1189
            try:
 
1190
                self.update_revisions(source,stop_revision)
 
1191
            except DivergedBranches:
 
1192
                if not overwrite:
 
1193
                    raise
 
1194
            if overwrite:
 
1195
                self.set_revision_history(source.revision_history())
 
1196
            new_count = len(self.revision_history())
 
1197
            return new_count - old_count
 
1198
        finally:
 
1199
            source.unlock()
 
1200
 
 
1201
    def get_parent(self):
 
1202
        """See Branch.get_parent."""
 
1203
 
2536
1204
        _locs = ['parent', 'pull', 'x-pull']
 
1205
        assert self.base[-1] == '/'
2537
1206
        for l in _locs:
2538
1207
            try:
2539
 
                return self._transport.get_bytes(l).strip('\n')
2540
 
            except errors.NoSuchFile:
2541
 
                pass
 
1208
                parent = self.control_files.get(l).read().strip('\n')
 
1209
            except NoSuchFile:
 
1210
                continue
 
1211
            # This is an old-format absolute path to a local branch
 
1212
            # turn it into a url
 
1213
            if parent.startswith('/'):
 
1214
                parent = urlutils.local_path_to_url(parent.decode('utf8'))
 
1215
            try:
 
1216
                return urlutils.join(self.base[:-1], parent)
 
1217
            except errors.InvalidURLJoin, e:
 
1218
                raise errors.InaccessibleParent(parent, self.base)
2542
1219
        return None
2543
1220
 
2544
 
    def get_stacked_on_url(self):
2545
 
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
 
1221
    def get_push_location(self):
 
1222
        """See Branch.get_push_location."""
 
1223
        push_loc = self.get_config().get_user_option('push_location')
 
1224
        return push_loc
2546
1225
 
2547
1226
    def set_push_location(self, location):
2548
1227
        """See Branch.set_push_location."""
2549
 
        self.get_config().set_user_option(
2550
 
            'push_location', location,
2551
 
            store=_mod_config.STORE_LOCATION_NORECURSE)
 
1228
        self.get_config().set_user_option('push_location', location, 
 
1229
                                          local=True)
2552
1230
 
2553
 
    def _set_parent_location(self, url):
 
1231
    @needs_write_lock
 
1232
    def set_parent(self, url):
 
1233
        """See Branch.set_parent."""
 
1234
        # TODO: Maybe delete old location files?
 
1235
        # URLs should never be unicode, even on the local fs,
 
1236
        # FIXUP this and get_parent in a future branch format bump:
 
1237
        # read and rewrite the file, and have the new format code read
 
1238
        # using .get not .get_utf8. RBC 20060125
2554
1239
        if url is None:
2555
 
            self._transport.delete('parent')
2556
 
        else:
2557
 
            self._transport.put_bytes('parent', url + '\n',
2558
 
                mode=self.bzrdir._get_file_mode())
2559
 
 
2560
 
    @needs_write_lock
2561
 
    def unbind(self):
2562
 
        """If bound, unbind"""
2563
 
        return self.set_bound_location(None)
 
1240
            self.control_files._transport.delete('parent')
 
1241
        else:
 
1242
            if isinstance(url, unicode):
 
1243
                try: 
 
1244
                    url = url.encode('ascii')
 
1245
                except UnicodeEncodeError:
 
1246
                    raise bzrlib.errors.InvalidURL(url,
 
1247
                        "Urls must be 7-bit ascii, "
 
1248
                        "use bzrlib.urlutils.escape")
 
1249
                    
 
1250
            url = urlutils.relative_url(self.base, url)
 
1251
            self.control_files.put('parent', url + '\n')
 
1252
 
 
1253
    @deprecated_function(zero_nine)
 
1254
    def tree_config(self):
 
1255
        """DEPRECATED; call get_config instead.  
 
1256
        TreeConfig has become part of BranchConfig."""
 
1257
        return TreeConfig(self)
 
1258
 
 
1259
 
 
1260
class BzrBranch5(BzrBranch):
 
1261
    """A format 5 branch. This supports new features over plan branches.
 
1262
 
 
1263
    It has support for a master_branch which is the data for bound branches.
 
1264
    """
 
1265
 
 
1266
    def __init__(self,
 
1267
                 _format,
 
1268
                 _control_files,
 
1269
                 a_bzrdir,
 
1270
                 _repository):
 
1271
        super(BzrBranch5, self).__init__(_format=_format,
 
1272
                                         _control_files=_control_files,
 
1273
                                         a_bzrdir=a_bzrdir,
 
1274
                                         _repository=_repository)
 
1275
        
 
1276
    @needs_write_lock
 
1277
    def pull(self, source, overwrite=False, stop_revision=None):
 
1278
        """Updates branch.pull to be bound branch aware."""
 
1279
        bound_location = self.get_bound_location()
 
1280
        if source.base != bound_location:
 
1281
            # not pulling from master, so we need to update master.
 
1282
            master_branch = self.get_master_branch()
 
1283
            if master_branch:
 
1284
                master_branch.pull(source)
 
1285
                source = master_branch
 
1286
        return super(BzrBranch5, self).pull(source, overwrite, stop_revision)
 
1287
 
 
1288
    def get_bound_location(self):
 
1289
        try:
 
1290
            return self.control_files.get_utf8('bound').read()[:-1]
 
1291
        except errors.NoSuchFile:
 
1292
            return None
 
1293
 
 
1294
    @needs_read_lock
 
1295
    def get_master_branch(self):
 
1296
        """Return the branch we are bound to.
 
1297
        
 
1298
        :return: Either a Branch, or None
 
1299
 
 
1300
        This could memoise the branch, but if thats done
 
1301
        it must be revalidated on each new lock.
 
1302
        So for now we just don't memoise it.
 
1303
        # RBC 20060304 review this decision.
 
1304
        """
 
1305
        bound_loc = self.get_bound_location()
 
1306
        if not bound_loc:
 
1307
            return None
 
1308
        try:
 
1309
            return Branch.open(bound_loc)
 
1310
        except (errors.NotBranchError, errors.ConnectionError), e:
 
1311
            raise errors.BoundBranchConnectionFailure(
 
1312
                    self, bound_loc, e)
 
1313
 
 
1314
    @needs_write_lock
 
1315
    def set_bound_location(self, location):
 
1316
        """Set the target where this branch is bound to.
 
1317
 
 
1318
        :param location: URL to the target branch
 
1319
        """
 
1320
        if location:
 
1321
            self.control_files.put_utf8('bound', location+'\n')
 
1322
        else:
 
1323
            try:
 
1324
                self.control_files._transport.delete('bound')
 
1325
            except NoSuchFile:
 
1326
                return False
 
1327
            return True
2564
1328
 
2565
1329
    @needs_write_lock
2566
1330
    def bind(self, other):
2567
 
        """Bind this branch to the branch other.
2568
 
 
2569
 
        This does not push or pull data between the branches, though it does
2570
 
        check for divergence to raise an error when the branches are not
2571
 
        either the same, or one a prefix of the other. That behaviour may not
2572
 
        be useful, so that check may be removed in future.
 
1331
        """Bind the local branch the other branch.
2573
1332
 
2574
1333
        :param other: The branch to bind to
2575
1334
        :type other: Branch
2581
1340
        #       but binding itself may not be.
2582
1341
        #       Since we *have* to check at commit time, we don't
2583
1342
        #       *need* to check here
2584
 
 
2585
 
        # we want to raise diverged if:
2586
 
        # last_rev is not in the other_last_rev history, AND
2587
 
        # other_last_rev is not in our history, and do it without pulling
2588
 
        # history around
 
1343
        self.pull(other)
 
1344
 
 
1345
        # we are now equal to or a suffix of other.
 
1346
 
 
1347
        # Since we have 'pulled' from the remote location,
 
1348
        # now we should try to pull in the opposite direction
 
1349
        # in case the local tree has more revisions than the
 
1350
        # remote one.
 
1351
        # There may be a different check you could do here
 
1352
        # rather than actually trying to install revisions remotely.
 
1353
        # TODO: capture an exception which indicates the remote branch
 
1354
        #       is not writable. 
 
1355
        #       If it is up-to-date, this probably should not be a failure
 
1356
        
 
1357
        # lock other for write so the revision-history syncing cannot race
 
1358
        other.lock_write()
 
1359
        try:
 
1360
            other.pull(self)
 
1361
            # if this does not error, other now has the same last rev we do
 
1362
            # it can only error if the pull from other was concurrent with
 
1363
            # a commit to other from someone else.
 
1364
 
 
1365
            # until we ditch revision-history, we need to sync them up:
 
1366
            self.set_revision_history(other.revision_history())
 
1367
            # now other and self are up to date with each other and have the
 
1368
            # same revision-history.
 
1369
        finally:
 
1370
            other.unlock()
 
1371
 
2589
1372
        self.set_bound_location(other.base)
2590
1373
 
2591
 
    def get_bound_location(self):
2592
 
        try:
2593
 
            return self._transport.get_bytes('bound')[:-1]
2594
 
        except errors.NoSuchFile:
2595
 
            return None
2596
 
 
2597
 
    @needs_read_lock
2598
 
    def get_master_branch(self, possible_transports=None):
2599
 
        """Return the branch we are bound to.
2600
 
 
2601
 
        :return: Either a Branch, or None
2602
 
        """
2603
 
        if self._master_branch_cache is None:
2604
 
            self._master_branch_cache = self._get_master_branch(
2605
 
                possible_transports)
2606
 
        return self._master_branch_cache
2607
 
 
2608
 
    def _get_master_branch(self, possible_transports):
2609
 
        bound_loc = self.get_bound_location()
2610
 
        if not bound_loc:
2611
 
            return None
2612
 
        try:
2613
 
            return Branch.open(bound_loc,
2614
 
                               possible_transports=possible_transports)
2615
 
        except (errors.NotBranchError, errors.ConnectionError), e:
2616
 
            raise errors.BoundBranchConnectionFailure(
2617
 
                    self, bound_loc, e)
2618
 
 
2619
 
    @needs_write_lock
2620
 
    def set_bound_location(self, location):
2621
 
        """Set the target where this branch is bound to.
2622
 
 
2623
 
        :param location: URL to the target branch
2624
 
        """
2625
 
        self._master_branch_cache = None
2626
 
        if location:
2627
 
            self._transport.put_bytes('bound', location+'\n',
2628
 
                mode=self.bzrdir._get_file_mode())
2629
 
        else:
2630
 
            try:
2631
 
                self._transport.delete('bound')
2632
 
            except errors.NoSuchFile:
2633
 
                return False
2634
 
            return True
2635
 
 
2636
 
    @needs_write_lock
2637
 
    def update(self, possible_transports=None):
2638
 
        """Synchronise this branch with the master branch if any.
 
1374
    @needs_write_lock
 
1375
    def unbind(self):
 
1376
        """If bound, unbind"""
 
1377
        return self.set_bound_location(None)
 
1378
 
 
1379
    @needs_write_lock
 
1380
    def update(self):
 
1381
        """Synchronise this branch with the master branch if any. 
2639
1382
 
2640
1383
        :return: None or the last_revision that was pivoted out during the
2641
1384
                 update.
2642
1385
        """
2643
 
        master = self.get_master_branch(possible_transports)
 
1386
        master = self.get_master_branch()
2644
1387
        if master is not None:
2645
 
            old_tip = _mod_revision.ensure_null(self.last_revision())
 
1388
            old_tip = self.last_revision()
2646
1389
            self.pull(master, overwrite=True)
2647
 
            if self.repository.get_graph().is_ancestor(old_tip,
2648
 
                _mod_revision.ensure_null(self.last_revision())):
 
1390
            if old_tip in self.repository.get_ancestry(self.last_revision()):
2649
1391
                return None
2650
1392
            return old_tip
2651
1393
        return None
2652
1394
 
2653
 
    def _read_last_revision_info(self):
2654
 
        revision_string = self._transport.get_bytes('last-revision')
2655
 
        revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
2656
 
        revision_id = cache_utf8.get_cached_utf8(revision_id)
2657
 
        revno = int(revno)
2658
 
        return revno, revision_id
2659
 
 
2660
 
    def _write_last_revision_info(self, revno, revision_id):
2661
 
        """Simply write out the revision id, with no checks.
2662
 
 
2663
 
        Use set_last_revision_info to perform this safely.
2664
 
 
2665
 
        Does not update the revision_history cache.
2666
 
        """
2667
 
        revision_id = _mod_revision.ensure_null(revision_id)
2668
 
        out_string = '%d %s\n' % (revno, revision_id)
2669
 
        self._transport.put_bytes('last-revision', out_string,
2670
 
            mode=self.bzrdir._get_file_mode())
2671
 
 
2672
 
    @needs_write_lock
2673
 
    def update_feature_flags(self, updated_flags):
2674
 
        """Update the feature flags for this branch.
2675
 
 
2676
 
        :param updated_flags: Dictionary mapping feature names to necessities
2677
 
            A necessity can be None to indicate the feature should be removed
2678
 
        """
2679
 
        self._format._update_feature_flags(updated_flags)
2680
 
        self.control_transport.put_bytes('format', self._format.as_string())
2681
 
 
2682
 
 
2683
 
class BzrBranch8(BzrBranch):
2684
 
    """A branch that stores tree-reference locations."""
2685
 
 
2686
 
    def _open_hook(self, possible_transports=None):
2687
 
        if self._ignore_fallbacks:
2688
 
            return
2689
 
        if possible_transports is None:
2690
 
            possible_transports = [self.bzrdir.root_transport]
2691
 
        try:
2692
 
            url = self.get_stacked_on_url()
2693
 
        except (errors.UnstackableRepositoryFormat, errors.NotStacked,
2694
 
            errors.UnstackableBranchFormat):
2695
 
            pass
2696
 
        else:
2697
 
            for hook in Branch.hooks['transform_fallback_location']:
2698
 
                url = hook(self, url)
2699
 
                if url is None:
2700
 
                    hook_name = Branch.hooks.get_hook_name(hook)
2701
 
                    raise AssertionError(
2702
 
                        "'transform_fallback_location' hook %s returned "
2703
 
                        "None, not a URL." % hook_name)
2704
 
            self._activate_fallback_location(url,
2705
 
                possible_transports=possible_transports)
2706
 
 
2707
 
    def __init__(self, *args, **kwargs):
2708
 
        self._ignore_fallbacks = kwargs.get('ignore_fallbacks', False)
2709
 
        super(BzrBranch8, self).__init__(*args, **kwargs)
2710
 
        self._last_revision_info_cache = None
2711
 
        self._reference_info = None
2712
 
 
2713
 
    def _clear_cached_state(self):
2714
 
        super(BzrBranch8, self)._clear_cached_state()
2715
 
        self._last_revision_info_cache = None
2716
 
        self._reference_info = None
2717
 
 
2718
 
    def _check_history_violation(self, revision_id):
2719
 
        current_revid = self.last_revision()
2720
 
        last_revision = _mod_revision.ensure_null(current_revid)
2721
 
        if _mod_revision.is_null(last_revision):
2722
 
            return
2723
 
        graph = self.repository.get_graph()
2724
 
        for lh_ancestor in graph.iter_lefthand_ancestry(revision_id):
2725
 
            if lh_ancestor == current_revid:
2726
 
                return
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
 
    @needs_write_lock
2737
 
    def _set_parent_location(self, url):
2738
 
        """Set the parent branch"""
2739
 
        self._set_config_location('parent_location', url, make_relative=True)
2740
 
 
2741
 
    @needs_read_lock
2742
 
    def _get_parent_location(self):
2743
 
        """Set the parent branch"""
2744
 
        return self._get_config_location('parent_location')
2745
 
 
2746
 
    @needs_write_lock
2747
 
    def _set_all_reference_info(self, info_dict):
2748
 
        """Replace all reference info stored in a branch.
2749
 
 
2750
 
        :param info_dict: A dict of {file_id: (tree_path, branch_location)}
2751
 
        """
2752
 
        s = StringIO()
2753
 
        writer = rio.RioWriter(s)
2754
 
        for key, (tree_path, branch_location) in info_dict.iteritems():
2755
 
            stanza = rio.Stanza(file_id=key, tree_path=tree_path,
2756
 
                                branch_location=branch_location)
2757
 
            writer.write_stanza(stanza)
2758
 
        self._transport.put_bytes('references', s.getvalue())
2759
 
        self._reference_info = info_dict
2760
 
 
2761
 
    @needs_read_lock
2762
 
    def _get_all_reference_info(self):
2763
 
        """Return all the reference info stored in a branch.
2764
 
 
2765
 
        :return: A dict of {file_id: (tree_path, branch_location)}
2766
 
        """
2767
 
        if self._reference_info is not None:
2768
 
            return self._reference_info
2769
 
        rio_file = self._transport.get('references')
2770
 
        try:
2771
 
            stanzas = rio.read_stanzas(rio_file)
2772
 
            info_dict = dict((s['file_id'], (s['tree_path'],
2773
 
                             s['branch_location'])) for s in stanzas)
2774
 
        finally:
2775
 
            rio_file.close()
2776
 
        self._reference_info = info_dict
2777
 
        return info_dict
2778
 
 
2779
 
    def set_reference_info(self, file_id, tree_path, branch_location):
2780
 
        """Set the branch location to use for a tree reference.
2781
 
 
2782
 
        :param file_id: The file-id of the tree reference.
2783
 
        :param tree_path: The path of the tree reference in the tree.
2784
 
        :param branch_location: The location of the branch to retrieve tree
2785
 
            references from.
2786
 
        """
2787
 
        info_dict = self._get_all_reference_info()
2788
 
        info_dict[file_id] = (tree_path, branch_location)
2789
 
        if None in (tree_path, branch_location):
2790
 
            if tree_path is not None:
2791
 
                raise ValueError('tree_path must be None when branch_location'
2792
 
                                 ' is None.')
2793
 
            if branch_location is not None:
2794
 
                raise ValueError('branch_location must be None when tree_path'
2795
 
                                 ' is None.')
2796
 
            del info_dict[file_id]
2797
 
        self._set_all_reference_info(info_dict)
2798
 
 
2799
 
    def get_reference_info(self, file_id):
2800
 
        """Get the tree_path and branch_location for a tree reference.
2801
 
 
2802
 
        :return: a tuple of (tree_path, branch_location)
2803
 
        """
2804
 
        return self._get_all_reference_info().get(file_id, (None, None))
2805
 
 
2806
 
    def reference_parent(self, file_id, path, possible_transports=None):
2807
 
        """Return the parent branch for a tree-reference file_id.
2808
 
 
2809
 
        :param file_id: The file_id of the tree reference
2810
 
        :param path: The path of the file_id in the tree
2811
 
        :return: A branch associated with the file_id
2812
 
        """
2813
 
        branch_location = self.get_reference_info(file_id)[1]
2814
 
        if branch_location is None:
2815
 
            return Branch.reference_parent(self, file_id, path,
2816
 
                                           possible_transports)
2817
 
        branch_location = urlutils.join(self.user_url, branch_location)
2818
 
        return Branch.open(branch_location,
2819
 
                           possible_transports=possible_transports)
2820
 
 
2821
 
    def set_push_location(self, location):
2822
 
        """See Branch.set_push_location."""
2823
 
        self._set_config_location('push_location', location)
2824
 
 
2825
 
    def set_bound_location(self, location):
2826
 
        """See Branch.set_push_location."""
2827
 
        self._master_branch_cache = None
2828
 
        result = None
2829
 
        conf = self.get_config_stack()
2830
 
        if location is None:
2831
 
            if not conf.get('bound'):
2832
 
                return False
2833
 
            else:
2834
 
                conf.set('bound', 'False')
2835
 
                return True
2836
 
        else:
2837
 
            self._set_config_location('bound_location', location,
2838
 
                                      config=conf)
2839
 
            conf.set('bound', 'True')
2840
 
        return True
2841
 
 
2842
 
    def _get_bound_location(self, bound):
2843
 
        """Return the bound location in the config file.
2844
 
 
2845
 
        Return None if the bound parameter does not match"""
2846
 
        conf = self.get_config_stack()
2847
 
        if conf.get('bound') != bound:
2848
 
            return None
2849
 
        return self._get_config_location('bound_location', config=conf)
2850
 
 
2851
 
    def get_bound_location(self):
2852
 
        """See Branch.get_bound_location."""
2853
 
        return self._get_bound_location(True)
2854
 
 
2855
 
    def get_old_bound_location(self):
2856
 
        """See Branch.get_old_bound_location"""
2857
 
        return self._get_bound_location(False)
2858
 
 
2859
 
    def get_stacked_on_url(self):
2860
 
        # you can always ask for the URL; but you might not be able to use it
2861
 
        # if the repo can't support stacking.
2862
 
        ## self._check_stackable_repo()
2863
 
        # stacked_on_location is only ever defined in branch.conf, so don't
2864
 
        # waste effort reading the whole stack of config files.
2865
 
        conf = _mod_config.BranchOnlyStack(self)
2866
 
        stacked_url = self._get_config_location('stacked_on_location',
2867
 
                                                config=conf)
2868
 
        if stacked_url is None:
2869
 
            raise errors.NotStacked(self)
2870
 
        return stacked_url.encode('utf-8')
2871
 
 
2872
 
    @needs_read_lock
2873
 
    def get_rev_id(self, revno, history=None):
2874
 
        """Find the revision id of the specified revno."""
2875
 
        if revno == 0:
2876
 
            return _mod_revision.NULL_REVISION
2877
 
 
2878
 
        last_revno, last_revision_id = self.last_revision_info()
2879
 
        if revno <= 0 or revno > last_revno:
2880
 
            raise errors.NoSuchRevision(self, revno)
2881
 
 
2882
 
        if history is not None:
2883
 
            return history[revno - 1]
2884
 
 
2885
 
        index = last_revno - revno
2886
 
        if len(self._partial_revision_history_cache) <= index:
2887
 
            self._extend_partial_history(stop_index=index)
2888
 
        if len(self._partial_revision_history_cache) > index:
2889
 
            return self._partial_revision_history_cache[index]
2890
 
        else:
2891
 
            raise errors.NoSuchRevision(self, revno)
2892
 
 
2893
 
    @needs_read_lock
2894
 
    def revision_id_to_revno(self, revision_id):
2895
 
        """Given a revision id, return its revno"""
2896
 
        if _mod_revision.is_null(revision_id):
2897
 
            return 0
2898
 
        try:
2899
 
            index = self._partial_revision_history_cache.index(revision_id)
2900
 
        except ValueError:
2901
 
            try:
2902
 
                self._extend_partial_history(stop_revision=revision_id)
2903
 
            except errors.RevisionNotPresent, e:
2904
 
                raise errors.GhostRevisionsHaveNoRevno(revision_id, e.revision_id)
2905
 
            index = len(self._partial_revision_history_cache) - 1
2906
 
            if index < 0:
2907
 
                raise errors.NoSuchRevision(self, revision_id)
2908
 
            if self._partial_revision_history_cache[index] != revision_id:
2909
 
                raise errors.NoSuchRevision(self, revision_id)
2910
 
        return self.revno() - index
2911
 
 
2912
 
 
2913
 
class BzrBranch7(BzrBranch8):
2914
 
    """A branch with support for a fallback repository."""
2915
 
 
2916
 
    def set_reference_info(self, file_id, tree_path, branch_location):
2917
 
        Branch.set_reference_info(self, file_id, tree_path, branch_location)
2918
 
 
2919
 
    def get_reference_info(self, file_id):
2920
 
        Branch.get_reference_info(self, file_id)
2921
 
 
2922
 
    def reference_parent(self, file_id, path, possible_transports=None):
2923
 
        return Branch.reference_parent(self, file_id, path,
2924
 
                                       possible_transports)
2925
 
 
2926
 
 
2927
 
class BzrBranch6(BzrBranch7):
2928
 
    """See BzrBranchFormat6 for the capabilities of this branch.
2929
 
 
2930
 
    This subclass of BzrBranch7 disables the new features BzrBranch7 added,
2931
 
    i.e. stacking.
2932
 
    """
2933
 
 
2934
 
    def get_stacked_on_url(self):
2935
 
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
2936
 
 
2937
 
 
2938
 
######################################################################
2939
 
# results of operations
2940
 
 
2941
 
 
2942
 
class _Result(object):
2943
 
 
2944
 
    def _show_tag_conficts(self, to_file):
2945
 
        if not getattr(self, 'tag_conflicts', None):
2946
 
            return
2947
 
        to_file.write('Conflicting tags:\n')
2948
 
        for name, value1, value2 in self.tag_conflicts:
2949
 
            to_file.write('    %s\n' % (name, ))
2950
 
 
2951
 
 
2952
 
class PullResult(_Result):
2953
 
    """Result of a Branch.pull operation.
2954
 
 
2955
 
    :ivar old_revno: Revision number before pull.
2956
 
    :ivar new_revno: Revision number after pull.
2957
 
    :ivar old_revid: Tip revision id before pull.
2958
 
    :ivar new_revid: Tip revision id after pull.
2959
 
    :ivar source_branch: Source (local) branch object. (read locked)
2960
 
    :ivar master_branch: Master branch of the target, or the target if no
2961
 
        Master
2962
 
    :ivar local_branch: target branch if there is a Master, else None
2963
 
    :ivar target_branch: Target/destination branch object. (write locked)
2964
 
    :ivar tag_conflicts: A list of tag conflicts, see BasicTags.merge_to
2965
 
    :ivar tag_updates: A dict with new tags, see BasicTags.merge_to
2966
 
    """
2967
 
 
2968
 
    def report(self, to_file):
2969
 
        tag_conflicts = getattr(self, "tag_conflicts", None)
2970
 
        tag_updates = getattr(self, "tag_updates", None)
2971
 
        if not is_quiet():
2972
 
            if self.old_revid != self.new_revid:
2973
 
                to_file.write('Now on revision %d.\n' % self.new_revno)
2974
 
            if tag_updates:
2975
 
                to_file.write('%d tag(s) updated.\n' % len(tag_updates))
2976
 
            if self.old_revid == self.new_revid and not tag_updates:
2977
 
                if not tag_conflicts:
2978
 
                    to_file.write('No revisions or tags to pull.\n')
2979
 
                else:
2980
 
                    to_file.write('No revisions to pull.\n')
2981
 
        self._show_tag_conficts(to_file)
2982
 
 
2983
 
 
2984
 
class BranchPushResult(_Result):
2985
 
    """Result of a Branch.push operation.
2986
 
 
2987
 
    :ivar old_revno: Revision number (eg 10) of the target before push.
2988
 
    :ivar new_revno: Revision number (eg 12) of the target after push.
2989
 
    :ivar old_revid: Tip revision id (eg joe@foo.com-1234234-aoeua34) of target
2990
 
        before the push.
2991
 
    :ivar new_revid: Tip revision id (eg joe@foo.com-5676566-boa234a) of target
2992
 
        after the push.
2993
 
    :ivar source_branch: Source branch object that the push was from. This is
2994
 
        read locked, and generally is a local (and thus low latency) branch.
2995
 
    :ivar master_branch: If target is a bound branch, the master branch of
2996
 
        target, or target itself. Always write locked.
2997
 
    :ivar target_branch: The direct Branch where data is being sent (write
2998
 
        locked).
2999
 
    :ivar local_branch: If the target is a bound branch this will be the
3000
 
        target, otherwise it will be None.
3001
 
    """
3002
 
 
3003
 
    def report(self, to_file):
3004
 
        # TODO: This function gets passed a to_file, but then
3005
 
        # ignores it and calls note() instead. This is also
3006
 
        # inconsistent with PullResult(), which writes to stdout.
3007
 
        # -- JRV20110901, bug #838853
3008
 
        tag_conflicts = getattr(self, "tag_conflicts", None)
3009
 
        tag_updates = getattr(self, "tag_updates", None)
3010
 
        if not is_quiet():
3011
 
            if self.old_revid != self.new_revid:
3012
 
                note(gettext('Pushed up to revision %d.') % self.new_revno)
3013
 
            if tag_updates:
3014
 
                note(ngettext('%d tag updated.', '%d tags updated.', len(tag_updates)) % len(tag_updates))
3015
 
            if self.old_revid == self.new_revid and not tag_updates:
3016
 
                if not tag_conflicts:
3017
 
                    note(gettext('No new revisions or tags to push.'))
3018
 
                else:
3019
 
                    note(gettext('No new revisions to push.'))
3020
 
        self._show_tag_conficts(to_file)
 
1395
 
 
1396
class BranchTestProviderAdapter(object):
 
1397
    """A tool to generate a suite testing multiple branch formats at once.
 
1398
 
 
1399
    This is done by copying the test once for each transport and injecting
 
1400
    the transport_server, transport_readonly_server, and branch_format
 
1401
    classes into each copy. Each copy is also given a new id() to make it
 
1402
    easy to identify.
 
1403
    """
 
1404
 
 
1405
    def __init__(self, transport_server, transport_readonly_server, formats):
 
1406
        self._transport_server = transport_server
 
1407
        self._transport_readonly_server = transport_readonly_server
 
1408
        self._formats = formats
 
1409
    
 
1410
    def adapt(self, test):
 
1411
        result = TestSuite()
 
1412
        for branch_format, bzrdir_format in self._formats:
 
1413
            new_test = deepcopy(test)
 
1414
            new_test.transport_server = self._transport_server
 
1415
            new_test.transport_readonly_server = self._transport_readonly_server
 
1416
            new_test.bzrdir_format = bzrdir_format
 
1417
            new_test.branch_format = branch_format
 
1418
            def make_new_test_id():
 
1419
                new_id = "%s(%s)" % (new_test.id(), branch_format.__class__.__name__)
 
1420
                return lambda: new_id
 
1421
            new_test.id = make_new_test_id()
 
1422
            result.addTest(new_test)
 
1423
        return result
3021
1424
 
3022
1425
 
3023
1426
class BranchCheckResult(object):
3028
1431
 
3029
1432
    def __init__(self, branch):
3030
1433
        self.branch = branch
3031
 
        self.errors = []
3032
1434
 
3033
1435
    def report_results(self, verbose):
3034
1436
        """Report the check results via trace.note.
3035
 
 
 
1437
        
3036
1438
        :param verbose: Requests more detailed display of what was checked,
3037
1439
            if any.
3038
1440
        """
3039
 
        note(gettext('checked branch {0} format {1}').format(
3040
 
                                self.branch.user_url, self.branch._format))
3041
 
        for error in self.errors:
3042
 
            note(gettext('found error:%s'), error)
3043
 
 
3044
 
 
3045
 
class Converter5to6(object):
3046
 
    """Perform an in-place upgrade of format 5 to format 6"""
3047
 
 
3048
 
    def convert(self, branch):
3049
 
        # Data for 5 and 6 can peacefully coexist.
3050
 
        format = BzrBranchFormat6()
3051
 
        new_branch = format.open(branch.bzrdir, _found=True)
3052
 
 
3053
 
        # Copy source data into target
3054
 
        new_branch._write_last_revision_info(*branch.last_revision_info())
3055
 
        new_branch.lock_write()
3056
 
        try:
3057
 
            new_branch.set_parent(branch.get_parent())
3058
 
            new_branch.set_bound_location(branch.get_bound_location())
3059
 
            new_branch.set_push_location(branch.get_push_location())
3060
 
        finally:
3061
 
            new_branch.unlock()
3062
 
 
3063
 
        # New branch has no tags by default
3064
 
        new_branch.tags._set_tag_dict({})
3065
 
 
3066
 
        # Copying done; now update target format
3067
 
        new_branch._transport.put_bytes('format',
3068
 
            format.as_string(),
3069
 
            mode=new_branch.bzrdir._get_file_mode())
3070
 
 
3071
 
        # Clean up old files
3072
 
        new_branch._transport.delete('revision-history')
3073
 
        branch.lock_write()
3074
 
        try:
3075
 
            try:
3076
 
                branch.set_parent(None)
3077
 
            except errors.NoSuchFile:
3078
 
                pass
3079
 
            branch.set_bound_location(None)
3080
 
        finally:
3081
 
            branch.unlock()
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.as_string())
3092
 
 
3093
 
 
3094
 
class Converter7to8(object):
3095
 
    """Perform an in-place upgrade of format 7 to format 8"""
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.as_string())
3102
 
 
3103
 
 
3104
 
class InterBranch(InterObject):
3105
 
    """This class represents operations taking place between two branches.
3106
 
 
3107
 
    Its instances have methods like pull() and push() and contain
3108
 
    references to the source and target repositories these operations
3109
 
    can be carried out on.
3110
 
    """
3111
 
 
3112
 
    _optimisers = []
3113
 
    """The available optimised InterBranch types."""
3114
 
 
3115
 
    @classmethod
3116
 
    def _get_branch_formats_to_test(klass):
3117
 
        """Return an iterable of format tuples for testing.
3118
 
        
3119
 
        :return: An iterable of (from_format, to_format) to use when testing
3120
 
            this InterBranch class. Each InterBranch class should define this
3121
 
            method itself.
3122
 
        """
3123
 
        raise NotImplementedError(klass._get_branch_formats_to_test)
3124
 
 
3125
 
    @needs_write_lock
3126
 
    def pull(self, overwrite=False, stop_revision=None,
3127
 
             possible_transports=None, local=False):
3128
 
        """Mirror source into target branch.
3129
 
 
3130
 
        The target branch is considered to be 'local', having low latency.
3131
 
 
3132
 
        :returns: PullResult instance
3133
 
        """
3134
 
        raise NotImplementedError(self.pull)
3135
 
 
3136
 
    @needs_write_lock
3137
 
    def push(self, overwrite=False, stop_revision=None, lossy=False,
3138
 
             _override_hook_source_branch=None):
3139
 
        """Mirror the source branch into the target branch.
3140
 
 
3141
 
        The source branch is considered to be 'local', having low latency.
3142
 
        """
3143
 
        raise NotImplementedError(self.push)
3144
 
 
3145
 
    @needs_write_lock
3146
 
    def copy_content_into(self, revision_id=None):
3147
 
        """Copy the content of source into target
3148
 
 
3149
 
        revision_id: if not None, the revision history in the new branch will
3150
 
                     be truncated to end with revision_id.
3151
 
        """
3152
 
        raise NotImplementedError(self.copy_content_into)
3153
 
 
3154
 
    @needs_write_lock
3155
 
    def fetch(self, stop_revision=None, limit=None):
3156
 
        """Fetch revisions.
3157
 
 
3158
 
        :param stop_revision: Last revision to fetch
3159
 
        :param limit: Optional rough limit of revisions to fetch
3160
 
        """
3161
 
        raise NotImplementedError(self.fetch)
3162
 
 
3163
 
 
3164
 
def _fix_overwrite_type(overwrite):
3165
 
    if isinstance(overwrite, bool):
3166
 
        if overwrite:
3167
 
            return ["history", "tags"]
3168
 
        else:
3169
 
            return []
3170
 
    return overwrite
3171
 
 
3172
 
 
3173
 
class GenericInterBranch(InterBranch):
3174
 
    """InterBranch implementation that uses public Branch functions."""
3175
 
 
3176
 
    @classmethod
3177
 
    def is_compatible(klass, source, target):
3178
 
        # GenericBranch uses the public API, so always compatible
3179
 
        return True
3180
 
 
3181
 
    @classmethod
3182
 
    def _get_branch_formats_to_test(klass):
3183
 
        return [(format_registry.get_default(), format_registry.get_default())]
3184
 
 
3185
 
    @classmethod
3186
 
    def unwrap_format(klass, format):
3187
 
        if isinstance(format, remote.RemoteBranchFormat):
3188
 
            format._ensure_real()
3189
 
            return format._custom_format
3190
 
        return format
3191
 
 
3192
 
    @needs_write_lock
3193
 
    def copy_content_into(self, revision_id=None):
3194
 
        """Copy the content of source into target
3195
 
 
3196
 
        revision_id: if not None, the revision history in the new branch will
3197
 
                     be truncated to end with revision_id.
3198
 
        """
3199
 
        self.source.update_references(self.target)
3200
 
        self.source._synchronize_history(self.target, revision_id)
3201
 
        try:
3202
 
            parent = self.source.get_parent()
3203
 
        except errors.InaccessibleParent, e:
3204
 
            mutter('parent was not accessible to copy: %s', e)
3205
 
        else:
3206
 
            if parent:
3207
 
                self.target.set_parent(parent)
3208
 
        if self.source._push_should_merge_tags():
3209
 
            self.source.tags.merge_to(self.target.tags)
3210
 
 
3211
 
    @needs_write_lock
3212
 
    def fetch(self, stop_revision=None, limit=None):
3213
 
        if self.target.base == self.source.base:
3214
 
            return (0, [])
3215
 
        self.source.lock_read()
3216
 
        try:
3217
 
            fetch_spec_factory = fetch.FetchSpecFactory()
3218
 
            fetch_spec_factory.source_branch = self.source
3219
 
            fetch_spec_factory.source_branch_stop_revision_id = stop_revision
3220
 
            fetch_spec_factory.source_repo = self.source.repository
3221
 
            fetch_spec_factory.target_repo = self.target.repository
3222
 
            fetch_spec_factory.target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
3223
 
            fetch_spec_factory.limit = limit
3224
 
            fetch_spec = fetch_spec_factory.make_fetch_spec()
3225
 
            return self.target.repository.fetch(self.source.repository,
3226
 
                fetch_spec=fetch_spec)
3227
 
        finally:
3228
 
            self.source.unlock()
3229
 
 
3230
 
    @needs_write_lock
3231
 
    def _update_revisions(self, stop_revision=None, overwrite=False,
3232
 
            graph=None):
3233
 
        other_revno, other_last_revision = self.source.last_revision_info()
3234
 
        stop_revno = None # unknown
3235
 
        if stop_revision is None:
3236
 
            stop_revision = other_last_revision
3237
 
            if _mod_revision.is_null(stop_revision):
3238
 
                # if there are no commits, we're done.
3239
 
                return
3240
 
            stop_revno = other_revno
3241
 
 
3242
 
        # what's the current last revision, before we fetch [and change it
3243
 
        # possibly]
3244
 
        last_rev = _mod_revision.ensure_null(self.target.last_revision())
3245
 
        # we fetch here so that we don't process data twice in the common
3246
 
        # case of having something to pull, and so that the check for
3247
 
        # already merged can operate on the just fetched graph, which will
3248
 
        # be cached in memory.
3249
 
        self.fetch(stop_revision=stop_revision)
3250
 
        # Check to see if one is an ancestor of the other
3251
 
        if not overwrite:
3252
 
            if graph is None:
3253
 
                graph = self.target.repository.get_graph()
3254
 
            if self.target._check_if_descendant_or_diverged(
3255
 
                    stop_revision, last_rev, graph, self.source):
3256
 
                # stop_revision is a descendant of last_rev, but we aren't
3257
 
                # overwriting, so we're done.
3258
 
                return
3259
 
        if stop_revno is None:
3260
 
            if graph is None:
3261
 
                graph = self.target.repository.get_graph()
3262
 
            this_revno, this_last_revision = \
3263
 
                    self.target.last_revision_info()
3264
 
            stop_revno = graph.find_distance_to_null(stop_revision,
3265
 
                            [(other_last_revision, other_revno),
3266
 
                             (this_last_revision, this_revno)])
3267
 
        self.target.set_last_revision_info(stop_revno, stop_revision)
3268
 
 
3269
 
    @needs_write_lock
3270
 
    def pull(self, overwrite=False, stop_revision=None,
3271
 
             possible_transports=None, run_hooks=True,
3272
 
             _override_hook_target=None, local=False):
3273
 
        """Pull from source into self, updating my master if any.
3274
 
 
3275
 
        :param run_hooks: Private parameter - if false, this branch
3276
 
            is being called because it's the master of the primary branch,
3277
 
            so it should not run its hooks.
3278
 
        """
3279
 
        bound_location = self.target.get_bound_location()
3280
 
        if local and not bound_location:
3281
 
            raise errors.LocalRequiresBoundBranch()
3282
 
        master_branch = None
3283
 
        source_is_master = False
3284
 
        if bound_location:
3285
 
            # bound_location comes from a config file, some care has to be
3286
 
            # taken to relate it to source.user_url
3287
 
            normalized = urlutils.normalize_url(bound_location)
3288
 
            try:
3289
 
                relpath = self.source.user_transport.relpath(normalized)
3290
 
                source_is_master = (relpath == '')
3291
 
            except (errors.PathNotChild, errors.InvalidURL):
3292
 
                source_is_master = False
3293
 
        if not local and bound_location and not source_is_master:
3294
 
            # not pulling from master, so we need to update master.
3295
 
            master_branch = self.target.get_master_branch(possible_transports)
3296
 
            master_branch.lock_write()
3297
 
        try:
3298
 
            if master_branch:
3299
 
                # pull from source into master.
3300
 
                master_branch.pull(self.source, overwrite, stop_revision,
3301
 
                    run_hooks=False)
3302
 
            return self._pull(overwrite,
3303
 
                stop_revision, _hook_master=master_branch,
3304
 
                run_hooks=run_hooks,
3305
 
                _override_hook_target=_override_hook_target,
3306
 
                merge_tags_to_master=not source_is_master)
3307
 
        finally:
3308
 
            if master_branch:
3309
 
                master_branch.unlock()
3310
 
 
3311
 
    def push(self, overwrite=False, stop_revision=None, lossy=False,
3312
 
             _override_hook_source_branch=None):
3313
 
        """See InterBranch.push.
3314
 
 
3315
 
        This is the basic concrete implementation of push()
3316
 
 
3317
 
        :param _override_hook_source_branch: If specified, run the hooks
3318
 
            passing this Branch as the source, rather than self.  This is for
3319
 
            use of RemoteBranch, where push is delegated to the underlying
3320
 
            vfs-based Branch.
3321
 
        """
3322
 
        if lossy:
3323
 
            raise errors.LossyPushToSameVCS(self.source, self.target)
3324
 
        # TODO: Public option to disable running hooks - should be trivial but
3325
 
        # needs tests.
3326
 
 
3327
 
        op = cleanup.OperationWithCleanups(self._push_with_bound_branches)
3328
 
        op.add_cleanup(self.source.lock_read().unlock)
3329
 
        op.add_cleanup(self.target.lock_write().unlock)
3330
 
        return op.run(overwrite, stop_revision,
3331
 
            _override_hook_source_branch=_override_hook_source_branch)
3332
 
 
3333
 
    def _basic_push(self, overwrite, stop_revision):
3334
 
        """Basic implementation of push without bound branches or hooks.
3335
 
 
3336
 
        Must be called with source read locked and target write locked.
3337
 
        """
3338
 
        result = BranchPushResult()
3339
 
        result.source_branch = self.source
3340
 
        result.target_branch = self.target
3341
 
        result.old_revno, result.old_revid = self.target.last_revision_info()
3342
 
        self.source.update_references(self.target)
3343
 
        overwrite = _fix_overwrite_type(overwrite)
3344
 
        if result.old_revid != stop_revision:
3345
 
            # We assume that during 'push' this repository is closer than
3346
 
            # the target.
3347
 
            graph = self.source.repository.get_graph(self.target.repository)
3348
 
            self._update_revisions(stop_revision,
3349
 
                overwrite=("history" in overwrite),
3350
 
                graph=graph)
3351
 
        if self.source._push_should_merge_tags():
3352
 
            result.tag_updates, result.tag_conflicts = (
3353
 
                self.source.tags.merge_to(
3354
 
                self.target.tags, "tags" in overwrite))
3355
 
        result.new_revno, result.new_revid = self.target.last_revision_info()
3356
 
        return result
3357
 
 
3358
 
    def _push_with_bound_branches(self, operation, overwrite, stop_revision,
3359
 
            _override_hook_source_branch=None):
3360
 
        """Push from source into target, and into target's master if any.
3361
 
        """
3362
 
        def _run_hooks():
3363
 
            if _override_hook_source_branch:
3364
 
                result.source_branch = _override_hook_source_branch
3365
 
            for hook in Branch.hooks['post_push']:
3366
 
                hook(result)
3367
 
 
3368
 
        bound_location = self.target.get_bound_location()
3369
 
        if bound_location and self.target.base != bound_location:
3370
 
            # there is a master branch.
3371
 
            #
3372
 
            # XXX: Why the second check?  Is it even supported for a branch to
3373
 
            # be bound to itself? -- mbp 20070507
3374
 
            master_branch = self.target.get_master_branch()
3375
 
            master_branch.lock_write()
3376
 
            operation.add_cleanup(master_branch.unlock)
3377
 
            # push into the master from the source branch.
3378
 
            master_inter = InterBranch.get(self.source, master_branch)
3379
 
            master_inter._basic_push(overwrite, stop_revision)
3380
 
            # and push into the target branch from the source. Note that
3381
 
            # we push from the source branch again, because it's considered
3382
 
            # the highest bandwidth repository.
3383
 
            result = self._basic_push(overwrite, stop_revision)
3384
 
            result.master_branch = master_branch
3385
 
            result.local_branch = self.target
3386
 
        else:
3387
 
            master_branch = None
3388
 
            # no master branch
3389
 
            result = self._basic_push(overwrite, stop_revision)
3390
 
            # TODO: Why set master_branch and local_branch if there's no
3391
 
            # binding?  Maybe cleaner to just leave them unset? -- mbp
3392
 
            # 20070504
3393
 
            result.master_branch = self.target
3394
 
            result.local_branch = None
3395
 
        _run_hooks()
3396
 
        return result
3397
 
 
3398
 
    def _pull(self, overwrite=False, stop_revision=None,
3399
 
             possible_transports=None, _hook_master=None, run_hooks=True,
3400
 
             _override_hook_target=None, local=False,
3401
 
             merge_tags_to_master=True):
3402
 
        """See Branch.pull.
3403
 
 
3404
 
        This function is the core worker, used by GenericInterBranch.pull to
3405
 
        avoid duplication when pulling source->master and source->local.
3406
 
 
3407
 
        :param _hook_master: Private parameter - set the branch to
3408
 
            be supplied as the master to pull hooks.
3409
 
        :param run_hooks: Private parameter - if false, this branch
3410
 
            is being called because it's the master of the primary branch,
3411
 
            so it should not run its hooks.
3412
 
            is being called because it's the master of the primary branch,
3413
 
            so it should not run its hooks.
3414
 
        :param _override_hook_target: Private parameter - set the branch to be
3415
 
            supplied as the target_branch to pull hooks.
3416
 
        :param local: Only update the local branch, and not the bound branch.
3417
 
        """
3418
 
        # This type of branch can't be bound.
3419
 
        if local:
3420
 
            raise errors.LocalRequiresBoundBranch()
3421
 
        result = PullResult()
3422
 
        result.source_branch = self.source
3423
 
        if _override_hook_target is None:
3424
 
            result.target_branch = self.target
3425
 
        else:
3426
 
            result.target_branch = _override_hook_target
3427
 
        self.source.lock_read()
3428
 
        try:
3429
 
            # We assume that during 'pull' the target repository is closer than
3430
 
            # the source one.
3431
 
            self.source.update_references(self.target)
3432
 
            graph = self.target.repository.get_graph(self.source.repository)
3433
 
            # TODO: Branch formats should have a flag that indicates 
3434
 
            # that revno's are expensive, and pull() should honor that flag.
3435
 
            # -- JRV20090506
3436
 
            result.old_revno, result.old_revid = \
3437
 
                self.target.last_revision_info()
3438
 
            overwrite = _fix_overwrite_type(overwrite)
3439
 
            self._update_revisions(stop_revision,
3440
 
                overwrite=("history" in overwrite),
3441
 
                graph=graph)
3442
 
            # TODO: The old revid should be specified when merging tags, 
3443
 
            # so a tags implementation that versions tags can only 
3444
 
            # pull in the most recent changes. -- JRV20090506
3445
 
            result.tag_updates, result.tag_conflicts = (
3446
 
                self.source.tags.merge_to(self.target.tags,
3447
 
                    "tags" in overwrite,
3448
 
                    ignore_master=not merge_tags_to_master))
3449
 
            result.new_revno, result.new_revid = self.target.last_revision_info()
3450
 
            if _hook_master:
3451
 
                result.master_branch = _hook_master
3452
 
                result.local_branch = result.target_branch
3453
 
            else:
3454
 
                result.master_branch = result.target_branch
3455
 
                result.local_branch = None
3456
 
            if run_hooks:
3457
 
                for hook in Branch.hooks['post_pull']:
3458
 
                    hook(result)
3459
 
        finally:
3460
 
            self.source.unlock()
3461
 
        return result
3462
 
 
3463
 
 
3464
 
InterBranch.register_optimiser(GenericInterBranch)
 
1441
        note('checked branch %s format %s',
 
1442
             self.branch.base,
 
1443
             self.branch._format)
 
1444
 
 
1445
 
 
1446
######################################################################
 
1447
# predicates
 
1448
 
 
1449
 
 
1450
@deprecated_function(zero_eight)
 
1451
def is_control_file(*args, **kwargs):
 
1452
    """See bzrlib.workingtree.is_control_file."""
 
1453
    return bzrlib.workingtree.is_control_file(*args, **kwargs)