~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Alexander Belchenko
  • Date: 2006-10-14 08:51:07 UTC
  • mto: (2080.1.1 jam-integration)
  • mto: This revision was merged to the branch mainline in revision 2081.
  • Revision ID: bialix@ukr.net-20061014085107-8dff865674eed30a
win32 installer: make short info page instead of full GPL license text

Show diffs side-by-side

added added

removed removed

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