~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Aaron Bentley
  • Date: 2007-06-11 14:59:52 UTC
  • mto: (2520.5.2 bzr.mpbundle)
  • mto: This revision was merged to the branch mainline in revision 2631.
  • Revision ID: abentley@panoramicfeedback.com-20070611145952-cwt4480gphdhen6l
Get installation started

Show diffs side-by-side

added added

removed removed

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