/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: Ian Clatworthy
  • Date: 2007-08-10 05:17:09 UTC
  • mto: (2733.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 2734.
  • Revision ID: ian.clatworthy@internode.on.net-20070810051709-0rnxlur94samh192
move most existing topics into the User Guide dir for English

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