/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Robert Collins
  • Date: 2007-03-01 01:02:30 UTC
  • mto: (2255.11.3 dirstate)
  • mto: This revision was merged to the branch mainline in revision 2322.
  • Revision ID: robertc@robertcollins.net-20070301010230-fh8p34iloqh7ua5j
Dont use a basis tree that is not in the tree's parents for revert testing - its not guaranteed usable.

Show diffs side-by-side

added added

removed removed

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