/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: 2008-04-17 08:21:14 UTC
  • mto: (4171.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 4173.
  • Revision ID: ian.clatworthy@canonical.com-20080417082114-76imbiarcbj16ov3
first cut at working tree content filtering

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
16
 
 
17
 
 
18
 
from cStringIO import StringIO
19
 
import sys
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
20
17
 
21
18
from bzrlib.lazy_import import lazy_import
22
19
lazy_import(globals(), """
23
 
from itertools import chain
24
20
from bzrlib import (
25
21
        bzrdir,
26
22
        cache_utf8,
31
27
        lockable_files,
32
28
        repository,
33
29
        revision as _mod_revision,
34
 
        rio,
35
 
        symbol_versioning,
36
30
        transport,
37
31
        tsort,
38
32
        ui,
39
33
        urlutils,
40
34
        )
41
 
from bzrlib.config import BranchConfig, TransportConfig
42
 
from bzrlib.repofmt.pack_repo import RepositoryFormatKnitPack5RichRoot
 
35
from bzrlib.config import BranchConfig
43
36
from bzrlib.tag import (
44
37
    BasicTags,
45
38
    DisabledTags,
46
39
    )
47
40
""")
48
41
 
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
 
    )
 
42
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
43
from bzrlib.hooks import Hooks
 
44
from bzrlib.symbol_versioning import (deprecated_method,
 
45
                                      zero_sixteen,
 
46
                                      )
58
47
from bzrlib.trace import mutter, mutter_callsite, note, is_quiet
59
48
 
60
49
 
63
52
BZR_BRANCH_FORMAT_6 = "Bazaar Branch Format 6 (bzr 0.15)\n"
64
53
 
65
54
 
66
 
class Branch(bzrdir.ControlComponent):
 
55
# TODO: Maybe include checks for common corruption of newlines, etc?
 
56
 
 
57
# TODO: Some operations like log might retrieve the same revisions
 
58
# repeatedly to calculate deltas.  We could perhaps have a weakref
 
59
# cache in memory to make this faster.  In general anything can be
 
60
# cached in memory between lock and unlock operations. .. nb thats
 
61
# what the transaction identity map provides
 
62
 
 
63
 
 
64
######################################################################
 
65
# branch objects
 
66
 
 
67
class Branch(object):
67
68
    """Branch holding a history of revisions.
68
69
 
69
 
    :ivar base:
70
 
        Base directory/url of the branch; using control_url and
71
 
        control_transport is more standardized.
 
70
    base
 
71
        Base directory/url of the branch.
72
72
 
73
73
    hooks: An instance of BranchHooks.
74
74
    """
76
76
    # - RBC 20060112
77
77
    base = None
78
78
 
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
 
79
    # override this to set the strategy for storing tags
 
80
    def _make_tags(self):
 
81
        return DisabledTags(self)
86
82
 
87
83
    def __init__(self, *ignored, **ignored_too):
88
 
        self.tags = self._format.make_tags(self)
 
84
        self.tags = self._make_tags()
89
85
        self._revision_history_cache = None
90
86
        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
87
 
110
88
    def break_lock(self):
111
89
        """Break a lock if one is present from another instance.
121
99
        if master is not None:
122
100
            master.break_lock()
123
101
 
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
102
    @staticmethod
159
103
    def open(base, _unsupported=False, possible_transports=None):
160
104
        """Open the branch rooted at base.
164
108
        """
165
109
        control = bzrdir.BzrDir.open(base, _unsupported,
166
110
                                     possible_transports=possible_transports)
167
 
        return control.open_branch(unsupported=_unsupported)
 
111
        return control.open_branch(_unsupported)
168
112
 
169
113
    @staticmethod
170
 
    def open_from_transport(transport, name=None, _unsupported=False):
 
114
    def open_from_transport(transport, _unsupported=False):
171
115
        """Open the branch rooted at transport"""
172
116
        control = bzrdir.BzrDir.open_from_transport(transport, _unsupported)
173
 
        return control.open_branch(name=name, unsupported=_unsupported)
 
117
        return control.open_branch(_unsupported)
174
118
 
175
119
    @staticmethod
176
120
    def open_containing(url, possible_transports=None):
177
121
        """Open an existing branch which contains url.
178
 
 
 
122
        
179
123
        This probes for a branch at url, and searches upwards from there.
180
124
 
181
125
        Basically we keep looking up until we find the control directory or
182
126
        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
 
127
        If there is one and it is either an unrecognised format or an unsupported 
184
128
        format, UnknownFormatError or UnsupportedFormatError are raised.
185
129
        If there is one, it is returned, along with the unused portion of url.
186
130
        """
188
132
                                                         possible_transports)
189
133
        return control.open_branch(), relpath
190
134
 
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()
198
 
 
199
135
    def get_config(self):
200
136
        return BranchConfig(self)
201
137
 
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()
 
138
    def _get_nick(self):
 
139
        return self.get_config().get_nickname()
250
140
 
251
141
    def _set_nick(self, nick):
252
142
        self.get_config().set_user_option('nickname', nick, warn_masked=True)
256
146
    def is_locked(self):
257
147
        raise NotImplementedError(self.is_locked)
258
148
 
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
 
        """
 
149
    def lock_write(self):
293
150
        raise NotImplementedError(self.lock_write)
294
151
 
295
152
    def lock_read(self):
296
 
        """Lock the branch for read operations.
297
 
 
298
 
        :return: A bzrlib.lock.LogicalLockResult.
299
 
        """
300
153
        raise NotImplementedError(self.lock_read)
301
154
 
302
155
    def unlock(self):
310
163
        raise NotImplementedError(self.get_physical_lock_status)
311
164
 
312
165
    @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
166
    def get_revision_id_to_revno_map(self):
378
167
        """Return the revision_id => dotted revno map.
379
168
 
403
192
 
404
193
        :return: A dictionary mapping revision_id => dotted revno.
405
194
        """
 
195
        last_revision = self.last_revision()
 
196
        revision_graph = repository._old_get_graph(self.repository,
 
197
            last_revision)
 
198
        merge_sorted_revisions = tsort.merge_sort(
 
199
            revision_graph,
 
200
            last_revision,
 
201
            None,
 
202
            generate_revno=True)
406
203
        revision_id_to_revno = dict((rev_id, revno)
407
 
            for rev_id, depth, revno, end_of_merge
408
 
             in self.iter_merge_sorted_revisions())
 
204
                                    for seq_num, rev_id, depth, revno, end_of_merge
 
205
                                     in merge_sorted_revisions)
409
206
        return revision_id_to_revno
410
207
 
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
208
    def leave_lock_in_place(self):
597
209
        """Tell this branch object not to release the physical lock when this
598
210
        object is unlocked.
599
 
 
 
211
        
600
212
        If lock_write doesn't return a token, then this method is not supported.
601
213
        """
602
214
        self.control_files.leave_in_place()
609
221
        """
610
222
        self.control_files.dont_leave_in_place()
611
223
 
 
224
    def abspath(self, name):
 
225
        """Return absolute filename for something in the branch
 
226
        
 
227
        XXX: Robert Collins 20051017 what is this used for? why is it a branch
 
228
        method and not a tree method.
 
229
        """
 
230
        raise NotImplementedError(self.abspath)
 
231
 
612
232
    def bind(self, other):
613
233
        """Bind the local branch the other branch.
614
234
 
615
235
        :param other: The branch to bind to
616
236
        :type other: Branch
617
237
        """
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)
 
238
        raise errors.UpgradeRequired(self.base)
637
239
 
638
240
    @needs_write_lock
639
241
    def fetch(self, from_branch, last_revision=None, pb=None):
643
245
        :param last_revision: What revision to stop at (None for at the end
644
246
                              of the branch.
645
247
        :param pb: An optional progress bar to use.
646
 
        :return: None
 
248
 
 
249
        Returns the copied revision count and the failed revisions in a tuple:
 
250
        (copied, failures).
647
251
        """
648
252
        if self.base == from_branch.base:
649
253
            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()")
 
254
        if pb is None:
 
255
            nested_pb = ui.ui_factory.nested_progress_bar()
 
256
            pb = nested_pb
 
257
        else:
 
258
            nested_pb = None
 
259
 
654
260
        from_branch.lock_read()
655
261
        try:
656
262
            if last_revision is None:
 
263
                pb.update('get source history')
657
264
                last_revision = from_branch.last_revision()
658
265
                last_revision = _mod_revision.ensure_null(last_revision)
659
266
            return self.repository.fetch(from_branch.repository,
660
267
                                         revision_id=last_revision,
661
 
                                         pb=pb)
 
268
                                         pb=nested_pb)
662
269
        finally:
 
270
            if nested_pb is not None:
 
271
                nested_pb.finished()
663
272
            from_branch.unlock()
664
273
 
665
274
    def get_bound_location(self):
669
278
        branch.
670
279
        """
671
280
        return None
672
 
 
 
281
    
673
282
    def get_old_bound_location(self):
674
283
        """Return the URL of the branch we used to be bound to
675
284
        """
676
 
        raise errors.UpgradeRequired(self.user_url)
 
285
        raise errors.UpgradeRequired(self.base)
677
286
 
678
 
    def get_commit_builder(self, parents, config=None, timestamp=None,
679
 
                           timezone=None, committer=None, revprops=None,
 
287
    def get_commit_builder(self, parents, config=None, timestamp=None, 
 
288
                           timezone=None, committer=None, revprops=None, 
680
289
                           revision_id=None):
681
290
        """Obtain a CommitBuilder for this branch.
682
 
 
 
291
        
683
292
        :param parents: Revision ids of the parents of the new revision.
684
293
        :param config: Optional configuration to use.
685
294
        :param timestamp: Optional timestamp recorded for commit.
691
300
 
692
301
        if config is None:
693
302
            config = self.get_config()
694
 
 
 
303
        
695
304
        return self.repository.get_commit_builder(self, parents, config,
696
305
            timestamp, timezone, committer, revprops, revision_id)
697
306
 
698
307
    def get_master_branch(self, possible_transports=None):
699
308
        """Return the branch we are bound to.
700
 
 
 
309
        
701
310
        :return: Either a Branch, or None
702
311
        """
703
312
        return None
708
317
        The delta is relative to its mainline predecessor, or the
709
318
        empty tree for revision 1.
710
319
        """
 
320
        assert isinstance(revno, int)
711
321
        rh = self.revision_history()
712
322
        if not (1 <= revno <= len(rh)):
713
323
            raise errors.InvalidRevisionNumber(revno)
714
324
        return self.repository.get_revision_delta(rh[revno-1])
715
325
 
716
 
    def get_stacked_on_url(self):
717
 
        """Get the URL this branch is stacked against.
 
326
    @deprecated_method(zero_sixteen)
 
327
    def get_root_id(self):
 
328
        """Return the id of this branches root
718
329
 
719
 
        :raises NotStacked: If the branch is not stacked.
720
 
        :raises UnstackableBranchFormat: If the branch does not support
721
 
            stacking.
 
330
        Deprecated: branches don't have root ids-- trees do.
 
331
        Use basis_tree().get_root_id() instead.
722
332
        """
723
 
        raise NotImplementedError(self.get_stacked_on_url)
 
333
        raise NotImplementedError(self.get_root_id)
724
334
 
725
335
    def print_file(self, file, revision_id):
726
336
        """Print `file` to stdout."""
729
339
    def set_revision_history(self, rev_history):
730
340
        raise NotImplementedError(self.set_revision_history)
731
341
 
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
342
    def _cache_revision_history(self, rev_history):
842
343
        """Set the cached revision history to rev_history.
843
344
 
868
369
        """
869
370
        self._revision_history_cache = None
870
371
        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
372
 
876
373
    def _gen_revision_history(self):
877
374
        """Return sequence of revision hashes on to this branch.
878
 
 
 
375
        
879
376
        Unlike revision_history, this method always regenerates or rereads the
880
377
        revision history, i.e. it does not cache the result, so repeated calls
881
378
        may be expensive.
882
379
 
883
380
        Concrete subclasses should override this instead of revision_history so
884
381
        that subclasses do not need to deal with caching logic.
885
 
 
 
382
        
886
383
        This API is semi-public; it only for use by subclasses, all other code
887
384
        should consider it to be private.
888
385
        """
891
388
    @needs_read_lock
892
389
    def revision_history(self):
893
390
        """Return sequence of revision ids on this branch.
894
 
 
 
391
        
895
392
        This method will cache the revision history for as long as it is safe to
896
393
        do so.
897
394
        """
914
411
 
915
412
    def unbind(self):
916
413
        """Older format branches cannot bind or unbind."""
917
 
        raise errors.UpgradeRequired(self.user_url)
 
414
        raise errors.UpgradeRequired(self.base)
 
415
 
 
416
    def set_append_revisions_only(self, enabled):
 
417
        """Older format branches are never restricted to append-only"""
 
418
        raise errors.UpgradeRequired(self.base)
918
419
 
919
420
    def last_revision(self):
920
421
        """Return last revision id, or NULL_REVISION."""
921
422
        return self.last_revision_info()[1]
922
423
 
923
 
    @needs_read_lock
924
424
    def last_revision_info(self):
925
425
        """Return information about the last revision.
926
426
 
927
 
        :return: A tuple (revno, revision_id).
 
427
        :return: A tuple (revno, last_revision_id).
928
428
        """
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
429
        rh = self.revision_history()
935
430
        revno = len(rh)
936
431
        if revno:
938
433
        else:
939
434
            return (0, _mod_revision.NULL_REVISION)
940
435
 
941
 
    @deprecated_method(deprecated_in((1, 6, 0)))
942
436
    def missing_revisions(self, other, stop_revision=None):
943
437
        """Return a list of new revisions that would perfectly fit.
944
 
 
 
438
        
945
439
        If self and other have not diverged, return a list of the revisions
946
440
        present in other, but missing from self.
947
441
        """
957
451
        if stop_revision is None:
958
452
            stop_revision = other_len
959
453
        else:
 
454
            assert isinstance(stop_revision, int)
960
455
            if stop_revision > other_len:
961
456
                raise errors.NoSuchRevision(self, stop_revision)
962
457
        return other_history[self_len:stop_revision]
963
458
 
964
 
    @needs_write_lock
965
 
    def update_revisions(self, other, stop_revision=None, overwrite=False,
966
 
                         graph=None):
 
459
    def update_revisions(self, other, stop_revision=None):
967
460
        """Pull in new perfect-fit revisions.
968
461
 
969
462
        :param other: Another Branch to pull from
970
463
        :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
464
        :return: None
976
465
        """
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)
 
466
        raise NotImplementedError(self.update_revisions)
993
467
 
994
468
    def revision_id_to_revno(self, revision_id):
995
469
        """Given a revision id, return its revno"""
1001
475
        except ValueError:
1002
476
            raise errors.NoSuchRevision(self, revision_id)
1003
477
 
1004
 
    @needs_read_lock
1005
478
    def get_rev_id(self, revno, history=None):
1006
479
        """Find the revision id of the specified revno."""
1007
480
        if revno == 0:
1008
481
            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:
 
482
        if history is None:
 
483
            history = self.revision_history()
 
484
        if revno <= 0 or revno > len(history):
1013
485
            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]
 
486
        return history[revno - 1]
1018
487
 
1019
 
    @needs_write_lock
1020
488
    def pull(self, source, overwrite=False, stop_revision=None,
1021
 
             possible_transports=None, *args, **kwargs):
 
489
             possible_transports=None):
1022
490
        """Mirror source into this branch.
1023
491
 
1024
492
        This branch is considered to be 'local', having low latency.
1025
493
 
1026
494
        :returns: PullResult instance
1027
495
        """
1028
 
        return InterBranch.get(source, self).pull(overwrite=overwrite,
1029
 
            stop_revision=stop_revision,
1030
 
            possible_transports=possible_transports, *args, **kwargs)
 
496
        raise NotImplementedError(self.pull)
1031
497
 
1032
 
    def push(self, target, overwrite=False, stop_revision=None, *args,
1033
 
        **kwargs):
 
498
    def push(self, target, overwrite=False, stop_revision=None):
1034
499
        """Mirror this branch into target.
1035
500
 
1036
501
        This branch is considered to be 'local', having low latency.
1037
502
        """
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)
 
503
        raise NotImplementedError(self.push)
1061
504
 
1062
505
    def basis_tree(self):
1063
506
        """Return `Tree` object for last revision."""
1064
507
        return self.repository.revision_tree(self.last_revision())
1065
508
 
 
509
    def rename_one(self, from_rel, to_rel):
 
510
        """Rename one file.
 
511
 
 
512
        This can change the directory or the filename or both.
 
513
        """
 
514
        raise NotImplementedError(self.rename_one)
 
515
 
 
516
    def move(self, from_paths, to_name):
 
517
        """Rename files.
 
518
 
 
519
        to_name must exist as a versioned directory.
 
520
 
 
521
        If to_name exists and is a directory, the files are moved into
 
522
        it, keeping their old names.  If it is a directory, 
 
523
 
 
524
        Note that to_name is only the last component of the new name;
 
525
        this doesn't change the directory.
 
526
 
 
527
        This returns a list of (from_path, to_path) pairs for each
 
528
        entry that is moved.
 
529
        """
 
530
        raise NotImplementedError(self.move)
 
531
 
1066
532
    def get_parent(self):
1067
533
        """Return the parent location of the branch.
1068
534
 
1069
 
        This is the default location for pull/missing.  The usual
 
535
        This is the default location for push/pull/missing.  The usual
1070
536
        pattern is that the user can override it by specifying a
1071
537
        location.
1072
538
        """
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)
 
539
        raise NotImplementedError(self.get_parent)
1087
540
 
1088
541
    def _set_config_location(self, name, url, config=None,
1089
542
                             make_relative=False):
1103
556
            location = None
1104
557
        return location
1105
558
 
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
559
    def get_submit_branch(self):
1111
560
        """Return the submit location of the branch.
1112
561
 
1129
578
    def get_public_branch(self):
1130
579
        """Return the public location of the branch.
1131
580
 
1132
 
        This is used by merge directives.
 
581
        This is is used by merge directives.
1133
582
        """
1134
583
        return self._get_config_location('public_branch')
1135
584
 
1151
600
        """Set a new push location for this branch."""
1152
601
        raise NotImplementedError(self.set_push_location)
1153
602
 
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)
 
603
    def set_parent(self, url):
 
604
        raise NotImplementedError(self.set_parent)
1175
605
 
1176
606
    @needs_write_lock
1177
607
    def update(self):
1178
 
        """Synchronise this branch with the master branch if any.
 
608
        """Synchronise this branch with the master branch if any. 
1179
609
 
1180
610
        :return: None or the last_revision pivoted out during the update.
1181
611
        """
1188
618
        """
1189
619
        if revno != 0:
1190
620
            self.check_real_revno(revno)
1191
 
 
 
621
            
1192
622
    def check_real_revno(self, revno):
1193
623
        """\
1194
624
        Check whether a revno corresponds to a real revision.
1198
628
            raise errors.InvalidRevisionNumber(revno)
1199
629
 
1200
630
    @needs_read_lock
1201
 
    def clone(self, to_bzrdir, revision_id=None, repository_policy=None):
 
631
    def clone(self, to_bzrdir, revision_id=None):
1202
632
        """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
 
 
 
633
        
1207
634
        revision_id: if not None, the revision history in the new branch will
1208
635
                     be truncated to end with revision_id.
1209
636
        """
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
 
637
        result = self._format.initialize(to_bzrdir)
 
638
        self.copy_content_into(result, revision_id=revision_id)
 
639
        return  result
1219
640
 
1220
641
    @needs_read_lock
1221
 
    def sprout(self, to_bzrdir, revision_id=None, repository_policy=None):
 
642
    def sprout(self, to_bzrdir, revision_id=None):
1222
643
        """Create a new line of development from the branch, into to_bzrdir.
1223
 
 
1224
 
        to_bzrdir controls the branch format.
1225
 
 
 
644
        
1226
645
        revision_id: if not None, the revision history in the new branch will
1227
646
                     be truncated to end with revision_id.
1228
647
        """
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()
 
648
        result = self._format.initialize(to_bzrdir)
 
649
        self.copy_content_into(result, revision_id=revision_id)
 
650
        result.set_parent(self.bzrdir.root_transport.base)
1241
651
        return result
1242
652
 
1243
653
    def _synchronize_history(self, destination, revision_id):
1244
654
        """Synchronize last revision and revision history between branches.
1245
655
 
1246
656
        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.
 
657
        BzrBranch5, but works for BzrBranch6 as long as the revision
 
658
        history is the true lefthand parent history, and all of the revisions
 
659
        are in the destination's repository.  If not, set_revision_history
 
660
        will fail.
1250
661
 
1251
662
        :param destination: The branch to copy the history into
1252
663
        :param revision_id: The revision-id to truncate history at.  May
1253
664
          be None to copy complete history.
1254
665
        """
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()
 
666
        if revision_id == _mod_revision.NULL_REVISION:
 
667
            new_history = []
 
668
        new_history = self.revision_history()
 
669
        if revision_id is not None and new_history != []:
1260
670
            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)
 
671
                new_history = new_history[:new_history.index(revision_id) + 1]
 
672
            except ValueError:
 
673
                rev = self.repository.get_revision(revision_id)
 
674
                new_history = rev.get_history(self.repository)[1:]
 
675
        destination.set_revision_history(new_history)
1267
676
 
1268
677
    @needs_read_lock
1269
678
    def copy_content_into(self, destination, revision_id=None):
1272
681
        revision_id: if not None, the revision history in the new branch will
1273
682
                     be truncated to end with revision_id.
1274
683
        """
1275
 
        self.update_references(destination)
1276
684
        self._synchronize_history(destination, revision_id)
1277
685
        try:
1278
686
            parent = self.get_parent()
1281
689
        else:
1282
690
            if parent:
1283
691
                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)
 
692
        self.tags.merge_to(destination.tags)
1303
693
 
1304
694
    @needs_read_lock
1305
 
    def check(self, refs):
 
695
    def check(self):
1306
696
        """Check consistency of the branch.
1307
697
 
1308
698
        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
 
699
        do actually match up in the revision graph, and that they're all 
1310
700
        present in the repository.
1311
 
 
 
701
        
1312
702
        Callers will typically also want to check the repository.
1313
703
 
1314
 
        :param refs: Calculated refs for this branch as specified by
1315
 
            branch._get_check_refs()
1316
704
        :return: A BranchCheckResult.
1317
705
        """
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
 
706
        mainline_parent_id = None
 
707
        for revision_id in self.revision_history():
 
708
            try:
 
709
                revision = self.repository.get_revision(revision_id)
 
710
            except errors.NoSuchRevision, e:
 
711
                raise errors.BzrCheckError("mainline revision {%s} not in repository"
 
712
                            % revision_id)
 
713
            # In general the first entry on the revision history has no parents.
 
714
            # But it's not illegal for it to have parents listed; this can happen
 
715
            # in imports from Arch when the parents weren't reachable.
 
716
            if mainline_parent_id is not None:
 
717
                if mainline_parent_id not in revision.parent_ids:
 
718
                    raise errors.BzrCheckError("previous revision {%s} not listed among "
 
719
                                        "parents of {%s}"
 
720
                                        % (mainline_parent_id, revision_id))
 
721
            mainline_parent_id = revision_id
 
722
        return BranchCheckResult(self)
1331
723
 
1332
724
    def _get_checkout_format(self):
1333
725
        """Return the most suitable metadir for a checkout of this branch.
1342
734
            format.set_branch_format(self._format)
1343
735
        return format
1344
736
 
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
737
    def create_checkout(self, to_location, revision_id=None,
1369
738
                        lightweight=False, accelerator_tree=None,
1370
739
                        hardlink=False):
1371
740
        """Create a checkout of a branch.
1372
 
 
 
741
        
1373
742
        :param to_location: The url to produce the checkout at
1374
743
        :param revision_id: The revision to check out
1375
744
        :param lightweight: If True, produce a lightweight checkout, otherwise,
1387
756
        if lightweight:
1388
757
            format = self._get_checkout_format()
1389
758
            checkout = format.initialize_on_transport(t)
1390
 
            from_branch = BranchReferenceFormat().initialize(checkout, 
1391
 
                target_branch=self)
 
759
            from_branch = BranchReferenceFormat().initialize(checkout, self)
1392
760
        else:
1393
761
            format = self._get_checkout_format()
1394
762
            checkout_branch = bzrdir.BzrDir.create_branch_convenience(
1395
763
                to_location, force_new_tree=False, format=format)
1396
764
            checkout = checkout_branch.bzrdir
1397
765
            checkout_branch.bind(self)
1398
 
            # pull up to the specified revision_id to set the initial
 
766
            # pull up to the specified revision_id to set the initial 
1399
767
            # branch tip correctly, and seed it with history.
1400
768
            checkout_branch.pull(self, stop_revision=revision_id)
1401
769
            from_branch=None
1415
783
            basis_tree.unlock()
1416
784
        return tree
1417
785
 
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):
 
786
    def reference_parent(self, file_id, path):
1427
787
        """Return the parent branch for a tree-reference file_id
1428
788
        :param file_id: The file_id of the tree reference
1429
789
        :param path: The path of the file_id in the tree
1430
790
        :return: A branch associated with the file_id
1431
791
        """
1432
792
        # FIXME should provide multiple branches, based on config
1433
 
        return Branch.open(self.bzrdir.root_transport.clone(path).base,
1434
 
                           possible_transports=possible_transports)
 
793
        return Branch.open(self.bzrdir.root_transport.clone(path).base)
1435
794
 
1436
795
    def supports_tags(self):
1437
796
        return self._format.supports_tags()
1438
797
 
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
798
 
1487
799
class BranchFormat(object):
1488
800
    """An encapsulation of the initialization and open routines for a format.
1492
804
     * a format string,
1493
805
     * an open routine.
1494
806
 
1495
 
    Formats are placed in an dict by their format string for reference
 
807
    Formats are placed in an dict by their format string for reference 
1496
808
    during branch opening. Its not required that these be instances, they
1497
 
    can be classes themselves with class methods - it simply depends on
 
809
    can be classes themselves with class methods - it simply depends on 
1498
810
    whether state is needed for a given format or not.
1499
811
 
1500
812
    Once a format is deprecated, just deprecate the initialize and open
1501
 
    methods on the format class. Do not deprecate the object, as the
 
813
    methods on the format class. Do not deprecate the object, as the 
1502
814
    object will be created every time regardless.
1503
815
    """
1504
816
 
1508
820
    _formats = {}
1509
821
    """The known formats."""
1510
822
 
1511
 
    can_set_append_revisions_only = True
1512
 
 
1513
823
    def __eq__(self, other):
1514
824
        return self.__class__ is other.__class__
1515
825
 
1517
827
        return not (self == other)
1518
828
 
1519
829
    @classmethod
1520
 
    def find_format(klass, a_bzrdir, name=None):
 
830
    def find_format(klass, a_bzrdir):
1521
831
        """Return the format for the branch object in a_bzrdir."""
1522
832
        try:
1523
 
            transport = a_bzrdir.get_branch_transport(None, name=name)
1524
 
            format_string = transport.get_bytes("format")
 
833
            transport = a_bzrdir.get_branch_transport(None)
 
834
            format_string = transport.get("format").read()
1525
835
            return klass._formats[format_string]
1526
836
        except errors.NoSuchFile:
1527
 
            raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
 
837
            raise errors.NotBranchError(path=transport.base)
1528
838
        except KeyError:
1529
839
            raise errors.UnknownFormatError(format=format_string, kind='branch')
1530
840
 
1533
843
        """Return the current default format."""
1534
844
        return klass._default_format
1535
845
 
1536
 
    def get_reference(self, a_bzrdir, name=None):
 
846
    def get_reference(self, a_bzrdir):
1537
847
        """Get the target reference of the branch in a_bzrdir.
1538
848
 
1539
849
        format probing must have been completed before calling
1541
851
        in a_bzrdir is correct.
1542
852
 
1543
853
        :param a_bzrdir: The bzrdir to get the branch data from.
1544
 
        :param name: Name of the colocated branch to fetch
1545
854
        :return: None if the branch is not a reference branch.
1546
855
        """
1547
856
        return None
1548
857
 
1549
858
    @classmethod
1550
 
    def set_reference(self, a_bzrdir, name, to_branch):
 
859
    def set_reference(self, a_bzrdir, to_branch):
1551
860
        """Set the target reference of the branch in a_bzrdir.
1552
861
 
1553
862
        format probing must have been completed before calling
1555
864
        in a_bzrdir is correct.
1556
865
 
1557
866
        :param a_bzrdir: The bzrdir to set the branch reference for.
1558
 
        :param name: Name of colocated branch to set, None for default
1559
867
        :param to_branch: branch that the checkout is to reference
1560
868
        """
1561
869
        raise NotImplementedError(self.set_reference)
1568
876
        """Return the short format description for this format."""
1569
877
        raise NotImplementedError(self.get_format_description)
1570
878
 
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):
 
879
    def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
 
880
                           set_format=True):
1581
881
        """Initialize a branch in a bzrdir, with specified files
1582
882
 
1583
883
        :param a_bzrdir: The bzrdir to initialize the branch in
1584
884
        :param utf8_files: The files to create as a list of
1585
885
            (filename, content) tuples
1586
 
        :param name: Name of colocated branch to create, if any
1587
886
        :param set_format: If True, set the format with
1588
887
            self.get_format_string.  (BzrBranch4 has its format set
1589
888
            elsewhere)
1590
889
        :return: a branch in this format
1591
890
        """
1592
 
        mutter('creating branch %r in %s', self, a_bzrdir.user_url)
1593
 
        branch_transport = a_bzrdir.get_branch_transport(self, name=name)
 
891
        mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
 
892
        branch_transport = a_bzrdir.get_branch_transport(self)
1594
893
        lock_map = {
1595
894
            'metadir': ('lock', lockdir.LockDir),
1596
895
            'branch4': ('branch-lock', lockable_files.TransportLock),
1599
898
        control_files = lockable_files.LockableFiles(branch_transport,
1600
899
            lock_name, lock_class)
1601
900
        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
 
901
        control_files.lock_write()
1610
902
        if set_format:
1611
 
            utf8_files += [('format', self.get_format_string())]
 
903
            control_files.put_utf8('format', self.get_format_string())
1612
904
        try:
1613
 
            for (filename, content) in utf8_files:
1614
 
                branch_transport.put_bytes(
1615
 
                    filename, content,
1616
 
                    mode=a_bzrdir._get_file_mode())
 
905
            for file, content in utf8_files:
 
906
                control_files.put_utf8(file, content)
1617
907
        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
 
908
            control_files.unlock()
 
909
        return self.open(a_bzrdir, _found=True)
1623
910
 
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
 
        """
 
911
    def initialize(self, a_bzrdir):
 
912
        """Create a branch of this format in a_bzrdir."""
1629
913
        raise NotImplementedError(self.initialize)
1630
914
 
1631
915
    def is_supported(self):
1632
916
        """Is this format supported?
1633
917
 
1634
918
        Supported formats can be initialized and opened.
1635
 
        Unsupported formats may not support initialization or committing or
 
919
        Unsupported formats may not support initialization or committing or 
1636
920
        some other features depending on the reason for not being supported.
1637
921
        """
1638
922
        return True
1639
923
 
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):
 
924
    def open(self, a_bzrdir, _found=False):
1665
925
        """Return the branch object for a_bzrdir
1666
926
 
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.
 
927
        _found is a private parameter, do not use it. It is used to indicate
 
928
               if format probing has already be done.
1673
929
        """
1674
930
        raise NotImplementedError(self.open)
1675
931
 
1676
932
    @classmethod
1677
933
    def register_format(klass, format):
1678
 
        """Register a metadir format."""
1679
934
        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
935
 
1684
936
    @classmethod
1685
937
    def set_default_format(klass, format):
1686
938
        klass._default_format = format
1687
939
 
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
940
    @classmethod
1697
941
    def unregister_format(klass, format):
 
942
        assert klass._formats[format.get_format_string()] is format
1698
943
        del klass._formats[format.get_format_string()]
1699
944
 
1700
945
    def __str__(self):
1701
 
        return self.get_format_description().rstrip()
 
946
        return self.get_format_string().rstrip()
1702
947
 
1703
948
    def supports_tags(self):
1704
949
        """True if this format supports tags stored in the branch"""
1705
950
        return False  # by default
1706
951
 
 
952
    # XXX: Probably doesn't really belong here -- mbp 20070212
 
953
    def _initialize_control_files(self, a_bzrdir, utf8_files, lock_filename,
 
954
            lock_class):
 
955
        branch_transport = a_bzrdir.get_branch_transport(self)
 
956
        control_files = lockable_files.LockableFiles(branch_transport,
 
957
            lock_filename, lock_class)
 
958
        control_files.create_lock()
 
959
        control_files.lock_write()
 
960
        try:
 
961
            for filename, content in utf8_files:
 
962
                control_files.put_utf8(filename, content)
 
963
        finally:
 
964
            control_files.unlock()
 
965
 
1707
966
 
1708
967
class BranchHooks(Hooks):
1709
968
    """A dictionary mapping hook name to a list of callables for branch hooks.
1710
 
 
 
969
    
1711
970
    e.g. ['set_rh'] Is the list of items to be called when the
1712
971
    set_revision_history function is invoked.
1713
972
    """
1719
978
        notified.
1720
979
        """
1721
980
        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
 
 
 
981
        # Introduced in 0.15:
 
982
        # invoked whenever the revision history has been set
 
983
        # with set_revision_history. The api signature is
 
984
        # (branch, revision_history), and the branch will
 
985
        # be write-locked.
 
986
        self['set_rh'] = []
 
987
        # invoked after a push operation completes.
 
988
        # the api signature is
 
989
        # (push_result)
 
990
        # containing the members
 
991
        # (source, local, master, old_revno, old_revid, new_revno, new_revid)
 
992
        # where local is the local target branch or None, master is the target 
 
993
        # master branch, and the rest should be self explanatory. The source
 
994
        # is read locked and the target branches write locked. Source will
 
995
        # be the local low-latency branch.
 
996
        self['post_push'] = []
 
997
        # invoked after a pull operation completes.
 
998
        # the api signature is
 
999
        # (pull_result)
 
1000
        # containing the members
 
1001
        # (source, local, master, old_revno, old_revid, new_revno, new_revid)
 
1002
        # where local is the local branch or None, master is the target 
 
1003
        # master branch, and the rest should be self explanatory. The source
 
1004
        # is read locked and the target branches write locked. The local
 
1005
        # branch is the low-latency branch.
 
1006
        self['post_pull'] = []
 
1007
        # invoked before a commit operation takes place.
 
1008
        # the api signature is
 
1009
        # (local, master, old_revno, old_revid, future_revno, future_revid,
 
1010
        #  tree_delta, future_tree).
 
1011
        # old_revid is NULL_REVISION for the first commit to a branch
 
1012
        # tree_delta is a TreeDelta object describing changes from the basis
 
1013
        # revision, hooks MUST NOT modify this delta
 
1014
        # future_tree is an in-memory tree obtained from
 
1015
        # CommitBuilder.revision_tree() and hooks MUST NOT modify this tree
 
1016
        self['pre_commit'] = []
 
1017
        # invoked after a commit operation completes.
 
1018
        # the api signature is 
 
1019
        # (local, master, old_revno, old_revid, new_revno, new_revid)
 
1020
        # old_revid is NULL_REVISION for the first commit to a branch.
 
1021
        self['post_commit'] = []
 
1022
        # invoked after a uncommit operation completes.
 
1023
        # the api signature is
 
1024
        # (local, master, old_revno, old_revid, new_revno, new_revid) where
 
1025
        # local is the local branch or None, master is the target branch,
 
1026
        # and an empty branch recieves new_revno of 0, new_revid of None.
 
1027
        self['post_uncommit'] = []
 
1028
        # Introduced in 1.4
 
1029
        # Invoked after the tip of a branch changes.
 
1030
        # the api signature is
 
1031
        # (params) where params is a ChangeBranchTipParams with the members
 
1032
        # (branch, old_revno, new_revno, old_revid, new_revid)
 
1033
        self['post_change_branch_tip'] = []
1799
1034
 
1800
1035
 
1801
1036
# install the default hooks into the Branch class.
1831
1066
        self.old_revid = old_revid
1832
1067
        self.new_revid = new_revid
1833
1068
 
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
1069
 
1921
1070
class BzrBranchFormat4(BranchFormat):
1922
1071
    """Bzr branch format 4.
1930
1079
        """See BranchFormat.get_format_description()."""
1931
1080
        return "Branch format 4"
1932
1081
 
1933
 
    def initialize(self, a_bzrdir, name=None):
 
1082
    def initialize(self, a_bzrdir):
1934
1083
        """Create a branch of this format in a_bzrdir."""
1935
1084
        utf8_files = [('revision-history', ''),
1936
1085
                      ('branch-name', ''),
1937
1086
                      ]
1938
 
        return self._initialize_helper(a_bzrdir, utf8_files, name=name,
 
1087
        return self._initialize_helper(a_bzrdir, utf8_files,
1939
1088
                                       lock_type='branch4', set_format=False)
1940
1089
 
1941
1090
    def __init__(self):
1942
1091
        super(BzrBranchFormat4, self).__init__()
1943
1092
        self._matchingbzrdir = bzrdir.BzrDirFormat6()
1944
1093
 
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()
 
1094
    def open(self, a_bzrdir, _found=False):
 
1095
        """Return the branch object for a_bzrdir
1948
1096
 
1949
 
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
1950
 
        """See BranchFormat.open()."""
 
1097
        _found is a private parameter, do not use it. It is used to indicate
 
1098
               if format probing has already be done.
 
1099
        """
1951
1100
        if not _found:
1952
1101
            # we are being called directly and must probe.
1953
1102
            raise NotImplementedError
1954
1103
        return BzrBranch(_format=self,
1955
1104
                         _control_files=a_bzrdir._control_files,
1956
1105
                         a_bzrdir=a_bzrdir,
1957
 
                         name=name,
1958
1106
                         _repository=a_bzrdir.open_repository())
1959
1107
 
1960
1108
    def __str__(self):
1961
1109
        return "Bazaar-NG branch format 4"
1962
1110
 
1963
1111
 
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.
1975
 
        """
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
 
        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)
1986
 
        try:
1987
 
            control_files = lockable_files.LockableFiles(transport, 'lock',
1988
 
                                                         lockdir.LockDir)
1989
 
            return self._branch_class()(_format=self,
1990
 
                              _control_files=control_files,
1991
 
                              name=name,
1992
 
                              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):
 
1112
class BzrBranchFormat5(BranchFormat):
2008
1113
    """Bzr branch format 5.
2009
1114
 
2010
1115
    This format has:
2017
1122
    This format is new in bzr 0.8.
2018
1123
    """
2019
1124
 
2020
 
    def _branch_class(self):
2021
 
        return BzrBranch5
2022
 
 
2023
1125
    def get_format_string(self):
2024
1126
        """See BranchFormat.get_format_string()."""
2025
1127
        return "Bazaar-NG branch format 5\n"
2027
1129
    def get_format_description(self):
2028
1130
        """See BranchFormat.get_format_description()."""
2029
1131
        return "Branch format 5"
2030
 
 
2031
 
    def initialize(self, a_bzrdir, name=None):
 
1132
        
 
1133
    def initialize(self, a_bzrdir):
2032
1134
        """Create a branch of this format in a_bzrdir."""
2033
1135
        utf8_files = [('revision-history', ''),
2034
1136
                      ('branch-name', ''),
2035
1137
                      ]
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):
 
1138
        return self._initialize_helper(a_bzrdir, utf8_files)
 
1139
 
 
1140
    def __init__(self):
 
1141
        super(BzrBranchFormat5, self).__init__()
 
1142
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
 
1143
 
 
1144
    def open(self, a_bzrdir, _found=False):
 
1145
        """Return the branch object for a_bzrdir
 
1146
 
 
1147
        _found is a private parameter, do not use it. It is used to indicate
 
1148
               if format probing has already be done.
 
1149
        """
 
1150
        if not _found:
 
1151
            format = BranchFormat.find_format(a_bzrdir)
 
1152
            assert format.__class__ == self.__class__
 
1153
        try:
 
1154
            transport = a_bzrdir.get_branch_transport(None)
 
1155
            control_files = lockable_files.LockableFiles(transport, 'lock',
 
1156
                                                         lockdir.LockDir)
 
1157
            return BzrBranch5(_format=self,
 
1158
                              _control_files=control_files,
 
1159
                              a_bzrdir=a_bzrdir,
 
1160
                              _repository=a_bzrdir.find_repository())
 
1161
        except errors.NoSuchFile:
 
1162
            raise errors.NotBranchError(path=transport.base)
 
1163
 
 
1164
 
 
1165
class BzrBranchFormat6(BzrBranchFormat5):
2043
1166
    """Branch format with last-revision and tags.
2044
1167
 
2045
1168
    Unlike previous formats, this has no explicit revision history. Instead,
2050
1173
    and became the default in 0.91.
2051
1174
    """
2052
1175
 
2053
 
    def _branch_class(self):
2054
 
        return BzrBranch6
2055
 
 
2056
1176
    def get_format_string(self):
2057
1177
        """See BranchFormat.get_format_string()."""
2058
1178
        return "Bazaar Branch Format 6 (bzr 0.15)\n"
2061
1181
        """See BranchFormat.get_format_description()."""
2062
1182
        return "Branch format 6"
2063
1183
 
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
 
1184
    def initialize(self, a_bzrdir):
 
1185
        """Create a branch of this format in a_bzrdir."""
 
1186
        utf8_files = [('last-revision', '0 null:\n'),
 
1187
                      ('branch.conf', ''),
 
1188
                      ('tags', ''),
 
1189
                      ]
 
1190
        return self._initialize_helper(a_bzrdir, utf8_files)
 
1191
 
 
1192
    def open(self, a_bzrdir, _found=False):
 
1193
        """Return the branch object for a_bzrdir
 
1194
 
 
1195
        _found is a private parameter, do not use it. It is used to indicate
 
1196
               if format probing has already be done.
 
1197
        """
 
1198
        if not _found:
 
1199
            format = BranchFormat.find_format(a_bzrdir)
 
1200
            assert format.__class__ == self.__class__
 
1201
        transport = a_bzrdir.get_branch_transport(None)
 
1202
        control_files = lockable_files.LockableFiles(transport, 'lock',
 
1203
                                                     lockdir.LockDir)
 
1204
        return BzrBranch6(_format=self,
 
1205
                          _control_files=control_files,
 
1206
                          a_bzrdir=a_bzrdir,
 
1207
                          _repository=a_bzrdir.find_repository())
 
1208
 
 
1209
    def supports_tags(self):
 
1210
        return True
2153
1211
 
2154
1212
 
2155
1213
class BranchReferenceFormat(BranchFormat):
2171
1229
        """See BranchFormat.get_format_description()."""
2172
1230
        return "Checkout reference format 1"
2173
1231
 
2174
 
    def get_reference(self, a_bzrdir, name=None):
 
1232
    def get_reference(self, a_bzrdir):
2175
1233
        """See BranchFormat.get_reference()."""
2176
 
        transport = a_bzrdir.get_branch_transport(None, name=name)
2177
 
        return transport.get_bytes('location')
 
1234
        transport = a_bzrdir.get_branch_transport(None)
 
1235
        return transport.get('location').read()
2178
1236
 
2179
 
    def set_reference(self, a_bzrdir, name, to_branch):
 
1237
    def set_reference(self, a_bzrdir, to_branch):
2180
1238
        """See BranchFormat.set_reference()."""
2181
 
        transport = a_bzrdir.get_branch_transport(None, name=name)
 
1239
        transport = a_bzrdir.get_branch_transport(None)
2182
1240
        location = transport.put_bytes('location', to_branch.base)
2183
1241
 
2184
 
    def initialize(self, a_bzrdir, name=None, target_branch=None):
 
1242
    def initialize(self, a_bzrdir, target_branch=None):
2185
1243
        """Create a branch of this format in a_bzrdir."""
2186
1244
        if target_branch is None:
2187
1245
            # this format does not implement branch itself, thus the implicit
2188
1246
            # creation contract must see it as uninitializable
2189
1247
            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)
 
1248
        mutter('creating branch reference in %s', a_bzrdir.transport.base)
 
1249
        branch_transport = a_bzrdir.get_branch_transport(self)
2192
1250
        branch_transport.put_bytes('location',
2193
 
            target_branch.bzrdir.user_url)
 
1251
            target_branch.bzrdir.root_transport.base)
2194
1252
        branch_transport.put_bytes('format', self.get_format_string())
2195
 
        branch = self.open(
2196
 
            a_bzrdir, name, _found=True,
 
1253
        return self.open(
 
1254
            a_bzrdir, _found=True,
2197
1255
            possible_transports=[target_branch.bzrdir.root_transport])
2198
 
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2199
 
        return branch
2200
1256
 
2201
1257
    def __init__(self):
2202
1258
        super(BranchReferenceFormat, self).__init__()
2203
1259
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
2204
 
        self._matchingbzrdir.set_branch_format(self)
2205
1260
 
2206
1261
    def _make_reference_clone_function(format, a_branch):
2207
1262
        """Create a clone() routine for a branch dynamically."""
2208
 
        def clone(to_bzrdir, revision_id=None,
2209
 
            repository_policy=None):
 
1263
        def clone(to_bzrdir, revision_id=None):
2210
1264
            """See Branch.clone()."""
2211
 
            return format.initialize(to_bzrdir, target_branch=a_branch)
 
1265
            return format.initialize(to_bzrdir, a_branch)
2212
1266
            # cannot obey revision_id limits when cloning a reference ...
2213
1267
            # FIXME RBC 20060210 either nuke revision_id for clone, or
2214
1268
            # emit some sort of warning/error to the caller ?!
2215
1269
        return clone
2216
1270
 
2217
 
    def open(self, a_bzrdir, name=None, _found=False, location=None,
2218
 
             possible_transports=None, ignore_fallbacks=False):
 
1271
    def open(self, a_bzrdir, _found=False, location=None,
 
1272
             possible_transports=None):
2219
1273
        """Return the branch that the branch reference in a_bzrdir points at.
2220
1274
 
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.
 
1275
        _found is a private parameter, do not use it. It is used to indicate
 
1276
               if format probing has already be done.
2231
1277
        """
2232
1278
        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))
 
1279
            format = BranchFormat.find_format(a_bzrdir)
 
1280
            assert format.__class__ == self.__class__
2237
1281
        if location is None:
2238
 
            location = self.get_reference(a_bzrdir, name)
 
1282
            location = self.get_reference(a_bzrdir)
2239
1283
        real_bzrdir = bzrdir.BzrDir.open(
2240
1284
            location, possible_transports=possible_transports)
2241
 
        result = real_bzrdir.open_branch(name=name, 
2242
 
            ignore_fallbacks=ignore_fallbacks)
 
1285
        result = real_bzrdir.open_branch()
2243
1286
        # this changes the behaviour of result.clone to create a new reference
2244
1287
        # rather than a copy of the content of the branch.
2245
1288
        # I did not use a proxy object because that needs much more extensive
2252
1295
        return result
2253
1296
 
2254
1297
 
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
1298
# formats which have no format string are not discoverable
2265
1299
# and not independently creatable, so are not registered.
2266
1300
__format5 = BzrBranchFormat5()
2267
1301
__format6 = BzrBranchFormat6()
2268
 
__format7 = BzrBranchFormat7()
2269
 
__format8 = BzrBranchFormat8()
2270
1302
BranchFormat.register_format(__format5)
2271
1303
BranchFormat.register_format(BranchReferenceFormat())
2272
1304
BranchFormat.register_format(__format6)
2273
 
BranchFormat.register_format(__format7)
2274
 
BranchFormat.register_format(__format8)
2275
 
BranchFormat.set_default_format(__format7)
 
1305
BranchFormat.set_default_format(__format6)
2276
1306
_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):
 
1307
                   ]
 
1308
 
 
1309
class BzrBranch(Branch):
2300
1310
    """A branch stored in the actual filesystem.
2301
1311
 
2302
1312
    Note that it's "local" in the context of the filesystem; it doesn't
2303
1313
    really matter if it's on an nfs/smb/afs/coda/... share, as long as
2304
1314
    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
1315
    """
2314
 
 
 
1316
    
2315
1317
    def __init__(self, _format=None,
2316
 
                 _control_files=None, a_bzrdir=None, name=None,
2317
 
                 _repository=None, ignore_fallbacks=False):
 
1318
                 _control_files=None, a_bzrdir=None, _repository=None):
2318
1319
        """Create new branch object at a particular location."""
 
1320
        Branch.__init__(self)
2319
1321
        if a_bzrdir is None:
2320
1322
            raise ValueError('a_bzrdir must be supplied')
2321
1323
        else:
2322
1324
            self.bzrdir = a_bzrdir
 
1325
        # self._transport used to point to the directory containing the
 
1326
        # control directory, but was not used - now it's just the transport
 
1327
        # for the branch control files.  mbp 20070212
2323
1328
        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
1329
        self._format = _format
2329
1330
        if _control_files is None:
2330
1331
            raise ValueError('BzrBranch _control_files is None')
2331
1332
        self.control_files = _control_files
2332
1333
        self._transport = _control_files._transport
2333
1334
        self.repository = _repository
2334
 
        Branch.__init__(self)
2335
1335
 
2336
1336
    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)
 
1337
        return '%s(%r)' % (self.__class__.__name__, self.base)
2342
1338
 
2343
1339
    __repr__ = __str__
2344
1340
 
2348
1344
 
2349
1345
    base = property(_get_base, doc="The URL for the root of this branch.")
2350
1346
 
2351
 
    def _get_config(self):
2352
 
        return TransportConfig(self._transport, 'branch.conf')
 
1347
    def abspath(self, name):
 
1348
        """See Branch.abspath."""
 
1349
        return self.control_files._transport.abspath(name)
 
1350
 
 
1351
 
 
1352
    @deprecated_method(zero_sixteen)
 
1353
    @needs_read_lock
 
1354
    def get_root_id(self):
 
1355
        """See Branch.get_root_id."""
 
1356
        tree = self.repository.revision_tree(self.last_revision())
 
1357
        return tree.get_root_id()
2353
1358
 
2354
1359
    def is_locked(self):
2355
1360
        return self.control_files.is_locked()
2356
1361
 
2357
1362
    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
 
1363
        repo_token = self.repository.lock_write()
2374
1364
        try:
2375
 
            return BranchWriteLockResult(self.unlock,
2376
 
                self.control_files.lock_write(token=token))
 
1365
            token = self.control_files.lock_write(token=token)
2377
1366
        except:
2378
 
            if took_lock:
2379
 
                self.repository.unlock()
 
1367
            self.repository.unlock()
2380
1368
            raise
 
1369
        return token
2381
1370
 
2382
1371
    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
 
1372
        self.repository.lock_read()
2397
1373
        try:
2398
1374
            self.control_files.lock_read()
2399
 
            return LogicalLockResult(self.unlock)
2400
1375
        except:
2401
 
            if took_lock:
2402
 
                self.repository.unlock()
 
1376
            self.repository.unlock()
2403
1377
            raise
2404
1378
 
2405
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
2406
1379
    def unlock(self):
 
1380
        # TODO: test for failed two phase locks. This is known broken.
2407
1381
        try:
2408
1382
            self.control_files.unlock()
2409
1383
        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
 
 
 
1384
            self.repository.unlock()
 
1385
        if not self.control_files.is_locked():
 
1386
            # we just released the lock
 
1387
            self._clear_cached_state()
 
1388
        
2419
1389
    def peek_lock_mode(self):
2420
1390
        if self.control_files._lock_count == 0:
2421
1391
            return None
2435
1405
 
2436
1406
        This performs the actual writing to disk.
2437
1407
        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())
 
1408
        self.control_files.put_bytes(
 
1409
            'revision-history', '\n'.join(history))
2441
1410
 
2442
1411
    @needs_write_lock
2443
1412
    def set_revision_history(self, rev_history):
2444
1413
        """See Branch.set_revision_history."""
2445
1414
        if 'evil' in debug.debug_flags:
2446
1415
            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)
2459
1416
        self._write_revision_history(rev_history)
2460
1417
        self._clear_cached_state()
2461
1418
        self._cache_revision_history(rev_history)
2462
1419
        for hook in Branch.hooks['set_rh']:
2463
1420
            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)
 
1421
 
 
1422
    def _run_post_change_branch_tip_hooks(self, old_revno, old_revid):
 
1423
        """Run the post_change_branch_tip hooks."""
 
1424
        hooks = Branch.hooks['post_change_branch_tip']
 
1425
        if not hooks:
2483
1426
            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
 
 
 
1427
        new_revno, new_revid = self.last_revision_info()
 
1428
        params = ChangeBranchTipParams(
 
1429
            self, old_revno, new_revno, old_revid, new_revid)
 
1430
        for hook in hooks:
 
1431
            hook(params)
 
1432
 
2496
1433
    @needs_write_lock
2497
1434
    def set_last_revision_info(self, revno, revision_id):
2498
1435
        """Set the last revision of this branch.
2501
1438
        for this revision id.
2502
1439
 
2503
1440
        It may be possible to set the branch last revision to an id not
2504
 
        present in the repository.  However, branches can also be
 
1441
        present in the repository.  However, branches can also be 
2505
1442
        configured to check constraints on history, in which case this may not
2506
1443
        be permitted.
2507
1444
        """
2508
1445
        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
 
1446
        old_revno, old_revid = self.last_revision_info()
2512
1447
        history = self._lefthand_history(revision_id)
2513
 
        if len(history) != revno:
2514
 
            raise AssertionError('%d != %d' % (len(history), revno))
 
1448
        assert len(history) == revno, '%d != %d' % (len(history), revno)
2515
1449
        self.set_revision_history(history)
 
1450
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2516
1451
 
2517
1452
    def _gen_revision_history(self):
2518
 
        history = self._transport.get_bytes('revision-history').split('\n')
 
1453
        history = self.control_files.get('revision-history').read().split('\n')
2519
1454
        if history[-1:] == ['']:
2520
1455
            # There shouldn't be a trailing newline, but just in case.
2521
1456
            history.pop()
2522
1457
        return history
2523
1458
 
 
1459
    def _lefthand_history(self, revision_id, last_rev=None,
 
1460
                          other_branch=None):
 
1461
        if 'evil' in debug.debug_flags:
 
1462
            mutter_callsite(4, "_lefthand_history scales with history.")
 
1463
        # stop_revision must be a descendant of last_revision
 
1464
        graph = self.repository.get_graph()
 
1465
        if last_rev is not None:
 
1466
            if not graph.is_ancestor(last_rev, revision_id):
 
1467
                # our previous tip is not merged into stop_revision
 
1468
                raise errors.DivergedBranches(self, other_branch)
 
1469
        # make a new revision history from the graph
 
1470
        parents_map = graph.get_parent_map([revision_id])
 
1471
        if revision_id not in parents_map:
 
1472
            raise errors.NoSuchRevision(self, revision_id)
 
1473
        current_rev_id = revision_id
 
1474
        new_history = []
 
1475
        # Do not include ghosts or graph origin in revision_history
 
1476
        while (current_rev_id in parents_map and
 
1477
               len(parents_map[current_rev_id]) > 0):
 
1478
            new_history.append(current_rev_id)
 
1479
            current_rev_id = parents_map[current_rev_id][0]
 
1480
            parents_map = graph.get_parent_map([current_rev_id])
 
1481
        new_history.reverse()
 
1482
        return new_history
 
1483
 
2524
1484
    @needs_write_lock
2525
1485
    def generate_revision_history(self, revision_id, last_rev=None,
2526
1486
        other_branch=None):
2535
1495
        self.set_revision_history(self._lefthand_history(revision_id,
2536
1496
            last_rev, other_branch))
2537
1497
 
 
1498
    @needs_write_lock
 
1499
    def update_revisions(self, other, stop_revision=None, overwrite=False):
 
1500
        """See Branch.update_revisions."""
 
1501
        other.lock_read()
 
1502
        try:
 
1503
            other_last_revno, other_last_revision = other.last_revision_info()
 
1504
            if stop_revision is None:
 
1505
                stop_revision = other_last_revision
 
1506
                if _mod_revision.is_null(stop_revision):
 
1507
                    # if there are no commits, we're done.
 
1508
                    return
 
1509
            # whats the current last revision, before we fetch [and change it
 
1510
            # possibly]
 
1511
            last_rev = _mod_revision.ensure_null(self.last_revision())
 
1512
            # we fetch here so that we don't process data twice in the common
 
1513
            # case of having something to pull, and so that the check for 
 
1514
            # already merged can operate on the just fetched graph, which will
 
1515
            # be cached in memory.
 
1516
            self.fetch(other, stop_revision)
 
1517
            # Check to see if one is an ancestor of the other
 
1518
            if not overwrite:
 
1519
                heads = self.repository.get_graph().heads([stop_revision,
 
1520
                                                           last_rev])
 
1521
                if heads == set([last_rev]):
 
1522
                    # The current revision is a decendent of the target,
 
1523
                    # nothing to do
 
1524
                    return
 
1525
                elif heads == set([stop_revision, last_rev]):
 
1526
                    # These branches have diverged
 
1527
                    raise errors.DivergedBranches(self, other)
 
1528
                assert heads == set([stop_revision])
 
1529
            if other_last_revision == stop_revision:
 
1530
                self.set_last_revision_info(other_last_revno,
 
1531
                                            other_last_revision)
 
1532
            else:
 
1533
                # TODO: jam 2007-11-29 Is there a way to determine the
 
1534
                #       revno without searching all of history??
 
1535
                if overwrite:
 
1536
                    self.generate_revision_history(stop_revision)
 
1537
                else:
 
1538
                    self.generate_revision_history(stop_revision,
 
1539
                        last_rev=last_rev, other_branch=other)
 
1540
        finally:
 
1541
            other.unlock()
 
1542
 
2538
1543
    def basis_tree(self):
2539
1544
        """See Branch.basis_tree."""
2540
1545
        return self.repository.revision_tree(self.last_revision())
2541
1546
 
 
1547
    @needs_write_lock
 
1548
    def pull(self, source, overwrite=False, stop_revision=None,
 
1549
             _hook_master=None, run_hooks=True, possible_transports=None):
 
1550
        """See Branch.pull.
 
1551
 
 
1552
        :param _hook_master: Private parameter - set the branch to 
 
1553
            be supplied as the master to push hooks.
 
1554
        :param run_hooks: Private parameter - if false, this branch
 
1555
            is being called because it's the master of the primary branch,
 
1556
            so it should not run its hooks.
 
1557
        """
 
1558
        result = PullResult()
 
1559
        result.source_branch = source
 
1560
        result.target_branch = self
 
1561
        source.lock_read()
 
1562
        try:
 
1563
            result.old_revno, result.old_revid = self.last_revision_info()
 
1564
            self.update_revisions(source, stop_revision, overwrite=overwrite)
 
1565
            result.tag_conflicts = source.tags.merge_to(self.tags, overwrite)
 
1566
            result.new_revno, result.new_revid = self.last_revision_info()
 
1567
            if _hook_master:
 
1568
                result.master_branch = _hook_master
 
1569
                result.local_branch = self
 
1570
            else:
 
1571
                result.master_branch = self
 
1572
                result.local_branch = None
 
1573
            if run_hooks:
 
1574
                for hook in Branch.hooks['post_pull']:
 
1575
                    hook(result)
 
1576
        finally:
 
1577
            source.unlock()
 
1578
        return result
 
1579
 
2542
1580
    def _get_parent_location(self):
2543
1581
        _locs = ['parent', 'pull', 'x-pull']
2544
1582
        for l in _locs:
2545
1583
            try:
2546
 
                return self._transport.get_bytes(l).strip('\n')
 
1584
                return self.control_files.get(l).read().strip('\n')
2547
1585
            except errors.NoSuchFile:
2548
1586
                pass
2549
1587
        return None
2550
1588
 
 
1589
    @needs_read_lock
 
1590
    def push(self, target, overwrite=False, stop_revision=None,
 
1591
             _override_hook_source_branch=None):
 
1592
        """See Branch.push.
 
1593
 
 
1594
        This is the basic concrete implementation of push()
 
1595
 
 
1596
        :param _override_hook_source_branch: If specified, run
 
1597
        the hooks passing this Branch as the source, rather than self.  
 
1598
        This is for use of RemoteBranch, where push is delegated to the
 
1599
        underlying vfs-based Branch. 
 
1600
        """
 
1601
        # TODO: Public option to disable running hooks - should be trivial but
 
1602
        # needs tests.
 
1603
        target.lock_write()
 
1604
        try:
 
1605
            result = self._push_with_bound_branches(target, overwrite,
 
1606
                    stop_revision,
 
1607
                    _override_hook_source_branch=_override_hook_source_branch)
 
1608
            return result
 
1609
        finally:
 
1610
            target.unlock()
 
1611
 
 
1612
    def _push_with_bound_branches(self, target, overwrite,
 
1613
            stop_revision,
 
1614
            _override_hook_source_branch=None):
 
1615
        """Push from self into target, and into target's master if any.
 
1616
        
 
1617
        This is on the base BzrBranch class even though it doesn't support 
 
1618
        bound branches because the *target* might be bound.
 
1619
        """
 
1620
        def _run_hooks():
 
1621
            if _override_hook_source_branch:
 
1622
                result.source_branch = _override_hook_source_branch
 
1623
            for hook in Branch.hooks['post_push']:
 
1624
                hook(result)
 
1625
 
 
1626
        bound_location = target.get_bound_location()
 
1627
        if bound_location and target.base != bound_location:
 
1628
            # there is a master branch.
 
1629
            #
 
1630
            # XXX: Why the second check?  Is it even supported for a branch to
 
1631
            # be bound to itself? -- mbp 20070507
 
1632
            master_branch = target.get_master_branch()
 
1633
            master_branch.lock_write()
 
1634
            try:
 
1635
                # push into the master from this branch.
 
1636
                self._basic_push(master_branch, overwrite, stop_revision)
 
1637
                # and push into the target branch from this. Note that we push from
 
1638
                # this branch again, because its considered the highest bandwidth
 
1639
                # repository.
 
1640
                result = self._basic_push(target, overwrite, stop_revision)
 
1641
                result.master_branch = master_branch
 
1642
                result.local_branch = target
 
1643
                _run_hooks()
 
1644
                return result
 
1645
            finally:
 
1646
                master_branch.unlock()
 
1647
        else:
 
1648
            # no master branch
 
1649
            result = self._basic_push(target, overwrite, stop_revision)
 
1650
            # TODO: Why set master_branch and local_branch if there's no
 
1651
            # binding?  Maybe cleaner to just leave them unset? -- mbp
 
1652
            # 20070504
 
1653
            result.master_branch = target
 
1654
            result.local_branch = None
 
1655
            _run_hooks()
 
1656
            return result
 
1657
 
2551
1658
    def _basic_push(self, target, overwrite, stop_revision):
2552
1659
        """Basic implementation of push without bound branches or hooks.
2553
1660
 
2554
 
        Must be called with source read locked and target write locked.
 
1661
        Must be called with self read locked and target write locked.
2555
1662
        """
2556
 
        result = BranchPushResult()
 
1663
        result = PushResult()
2557
1664
        result.source_branch = self
2558
1665
        result.target_branch = target
2559
1666
        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)
 
1667
        try:
 
1668
            target.update_revisions(self, stop_revision)
 
1669
        except errors.DivergedBranches:
 
1670
            if not overwrite:
 
1671
                raise
 
1672
        if overwrite:
 
1673
            target.set_revision_history(self.revision_history())
 
1674
        result.tag_conflicts = self.tags.merge_to(target.tags, overwrite)
2570
1675
        result.new_revno, result.new_revid = target.last_revision_info()
2571
1676
        return result
2572
1677
 
2573
 
    def get_stacked_on_url(self):
2574
 
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
 
1678
    def get_parent(self):
 
1679
        """See Branch.get_parent."""
 
1680
 
 
1681
        assert self.base[-1] == '/'
 
1682
        parent = self._get_parent_location()
 
1683
        if parent is None:
 
1684
            return parent
 
1685
        # This is an old-format absolute path to a local branch
 
1686
        # turn it into a url
 
1687
        if parent.startswith('/'):
 
1688
            parent = urlutils.local_path_to_url(parent.decode('utf8'))
 
1689
        try:
 
1690
            return urlutils.join(self.base[:-1], parent)
 
1691
        except errors.InvalidURLJoin, e:
 
1692
            raise errors.InaccessibleParent(parent, self.base)
2575
1693
 
2576
1694
    def set_push_location(self, location):
2577
1695
        """See Branch.set_push_location."""
2579
1697
            'push_location', location,
2580
1698
            store=_mod_config.STORE_LOCATION_NORECURSE)
2581
1699
 
 
1700
    @needs_write_lock
 
1701
    def set_parent(self, url):
 
1702
        """See Branch.set_parent."""
 
1703
        # TODO: Maybe delete old location files?
 
1704
        # URLs should never be unicode, even on the local fs,
 
1705
        # FIXUP this and get_parent in a future branch format bump:
 
1706
        # read and rewrite the file, and have the new format code read
 
1707
        # using .get not .get_utf8. RBC 20060125
 
1708
        if url is not None:
 
1709
            if isinstance(url, unicode):
 
1710
                try: 
 
1711
                    url = url.encode('ascii')
 
1712
                except UnicodeEncodeError:
 
1713
                    raise errors.InvalidURL(url,
 
1714
                        "Urls must be 7-bit ascii, "
 
1715
                        "use bzrlib.urlutils.escape")
 
1716
            url = urlutils.relative_url(self.base, url)
 
1717
        self._set_parent_location(url)
 
1718
 
2582
1719
    def _set_parent_location(self, url):
2583
1720
        if url is None:
2584
 
            self._transport.delete('parent')
 
1721
            self.control_files._transport.delete('parent')
2585
1722
        else:
2586
 
            self._transport.put_bytes('parent', url + '\n',
2587
 
                mode=self.bzrdir._get_file_mode())
 
1723
            assert isinstance(url, str)
 
1724
            self.control_files.put_bytes('parent', url + '\n')
2588
1725
 
2589
1726
 
2590
1727
class BzrBranch5(BzrBranch):
2593
1730
    It has support for a master_branch which is the data for bound branches.
2594
1731
    """
2595
1732
 
 
1733
    def __init__(self,
 
1734
                 _format,
 
1735
                 _control_files,
 
1736
                 a_bzrdir,
 
1737
                 _repository):
 
1738
        super(BzrBranch5, self).__init__(_format=_format,
 
1739
                                         _control_files=_control_files,
 
1740
                                         a_bzrdir=a_bzrdir,
 
1741
                                         _repository=_repository)
 
1742
        
 
1743
    @needs_write_lock
 
1744
    def pull(self, source, overwrite=False, stop_revision=None,
 
1745
             run_hooks=True, possible_transports=None):
 
1746
        """Pull from source into self, updating my master if any.
 
1747
        
 
1748
        :param run_hooks: Private parameter - if false, this branch
 
1749
            is being called because it's the master of the primary branch,
 
1750
            so it should not run its hooks.
 
1751
        """
 
1752
        bound_location = self.get_bound_location()
 
1753
        master_branch = None
 
1754
        if bound_location and source.base != bound_location:
 
1755
            # not pulling from master, so we need to update master.
 
1756
            master_branch = self.get_master_branch(possible_transports)
 
1757
            master_branch.lock_write()
 
1758
        try:
 
1759
            if master_branch:
 
1760
                # pull from source into master.
 
1761
                master_branch.pull(source, overwrite, stop_revision,
 
1762
                    run_hooks=False)
 
1763
            return super(BzrBranch5, self).pull(source, overwrite,
 
1764
                stop_revision, _hook_master=master_branch,
 
1765
                run_hooks=run_hooks)
 
1766
        finally:
 
1767
            if master_branch:
 
1768
                master_branch.unlock()
 
1769
 
2596
1770
    def get_bound_location(self):
2597
1771
        try:
2598
 
            return self._transport.get_bytes('bound')[:-1]
 
1772
            return self.control_files.get_utf8('bound').read()[:-1]
2599
1773
        except errors.NoSuchFile:
2600
1774
            return None
2601
1775
 
2602
1776
    @needs_read_lock
2603
1777
    def get_master_branch(self, possible_transports=None):
2604
1778
        """Return the branch we are bound to.
2605
 
 
 
1779
        
2606
1780
        :return: Either a Branch, or None
2607
1781
 
2608
1782
        This could memoise the branch, but if thats done
2627
1801
        :param location: URL to the target branch
2628
1802
        """
2629
1803
        if location:
2630
 
            self._transport.put_bytes('bound', location+'\n',
2631
 
                mode=self.bzrdir._get_file_mode())
 
1804
            self.control_files.put_utf8('bound', location+'\n')
2632
1805
        else:
2633
1806
            try:
2634
 
                self._transport.delete('bound')
 
1807
                self.control_files._transport.delete('bound')
2635
1808
            except errors.NoSuchFile:
2636
1809
                return False
2637
1810
            return True
2644
1817
        check for divergence to raise an error when the branches are not
2645
1818
        either the same, or one a prefix of the other. That behaviour may not
2646
1819
        be useful, so that check may be removed in future.
2647
 
 
 
1820
        
2648
1821
        :param other: The branch to bind to
2649
1822
        :type other: Branch
2650
1823
        """
2669
1842
 
2670
1843
    @needs_write_lock
2671
1844
    def update(self, possible_transports=None):
2672
 
        """Synchronise this branch with the master branch if any.
 
1845
        """Synchronise this branch with the master branch if any. 
2673
1846
 
2674
1847
        :return: None or the last_revision that was pivoted out during the
2675
1848
                 update.
2685
1858
        return None
2686
1859
 
2687
1860
 
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
2694
 
        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)
 
1861
class BzrBranch6(BzrBranch5):
2708
1862
 
2709
1863
    def __init__(self, *args, **kwargs):
2710
 
        self._ignore_fallbacks = kwargs.get('ignore_fallbacks', False)
2711
 
        super(BzrBranch8, self).__init__(*args, **kwargs)
 
1864
        super(BzrBranch6, self).__init__(*args, **kwargs)
2712
1865
        self._last_revision_info_cache = None
2713
 
        self._reference_info = None
 
1866
        self._partial_revision_history_cache = []
2714
1867
 
2715
1868
    def _clear_cached_state(self):
2716
 
        super(BzrBranch8, self)._clear_cached_state()
 
1869
        super(BzrBranch6, self)._clear_cached_state()
2717
1870
        self._last_revision_info_cache = None
2718
 
        self._reference_info = None
 
1871
        self._partial_revision_history_cache = []
 
1872
 
 
1873
    @needs_read_lock
 
1874
    def last_revision_info(self):
 
1875
        """Return information about the last revision.
 
1876
 
 
1877
        :return: A tuple (revno, revision_id).
 
1878
        """
 
1879
        if self._last_revision_info_cache is None:
 
1880
            self._last_revision_info_cache = self._last_revision_info()
 
1881
        return self._last_revision_info_cache
2719
1882
 
2720
1883
    def _last_revision_info(self):
2721
 
        revision_string = self._transport.get_bytes('last-revision')
 
1884
        revision_string = self.control_files.get('last-revision').read()
2722
1885
        revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
2723
1886
        revision_id = cache_utf8.get_cached_utf8(revision_id)
2724
1887
        revno = int(revno)
2733
1896
        Intended to be called by set_last_revision_info and
2734
1897
        _write_revision_history.
2735
1898
        """
2736
 
        revision_id = _mod_revision.ensure_null(revision_id)
 
1899
        assert revision_id is not None, "Use NULL_REVISION, not None"
2737
1900
        out_string = '%d %s\n' % (revno, revision_id)
2738
 
        self._transport.put_bytes('last-revision', out_string,
2739
 
            mode=self.bzrdir._get_file_mode())
 
1901
        self.control_files.put_bytes('last-revision', out_string)
2740
1902
 
2741
1903
    @needs_write_lock
2742
1904
    def set_last_revision_info(self, revno, revision_id):
2744
1906
        old_revno, old_revid = self.last_revision_info()
2745
1907
        if self._get_append_revisions_only():
2746
1908
            self._check_history_violation(revision_id)
2747
 
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2748
1909
        self._write_last_revision_info(revno, revision_id)
2749
1910
        self._clear_cached_state()
2750
1911
        self._last_revision_info_cache = revno, revision_id
2751
1912
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2752
1913
 
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
 
 
2765
1914
    def _check_history_violation(self, revision_id):
2766
1915
        last_revision = _mod_revision.ensure_null(self.last_revision())
2767
1916
        if _mod_revision.is_null(last_revision):
2768
1917
            return
2769
1918
        if last_revision not in self._lefthand_history(revision_id):
2770
 
            raise errors.AppendRevisionsOnlyViolation(self.user_url)
 
1919
            raise errors.AppendRevisionsOnlyViolation(self.base)
2771
1920
 
2772
1921
    def _gen_revision_history(self):
2773
1922
        """Generate the revision history from last revision
2774
1923
        """
2775
 
        last_revno, last_revision = self.last_revision_info()
2776
 
        self._extend_partial_history(stop_index=last_revno-1)
 
1924
        self._extend_partial_history()
2777
1925
        return list(reversed(self._partial_revision_history_cache))
2778
1926
 
 
1927
    def _extend_partial_history(self, stop_index=None, stop_revision=None):
 
1928
        """Extend the partial history to include a given index
 
1929
 
 
1930
        If a stop_index is supplied, stop when that index has been reached.
 
1931
        If a stop_revision is supplied, stop when that revision is
 
1932
        encountered.  Otherwise, stop when the beginning of history is
 
1933
        reached.
 
1934
 
 
1935
        :param stop_index: The index which should be present.  When it is
 
1936
            present, history extension will stop.
 
1937
        :param revision_id: The revision id which should be present.  When
 
1938
            it is encountered, history extension will stop.
 
1939
        """
 
1940
        repo = self.repository
 
1941
        if len(self._partial_revision_history_cache) == 0:
 
1942
            iterator = repo.iter_reverse_revision_history(self.last_revision())
 
1943
        else:
 
1944
            start_revision = self._partial_revision_history_cache[-1]
 
1945
            iterator = repo.iter_reverse_revision_history(start_revision)
 
1946
            #skip the last revision in the list
 
1947
            next_revision = iterator.next()
 
1948
            assert next_revision == start_revision
 
1949
        for revision_id in iterator:
 
1950
            self._partial_revision_history_cache.append(revision_id)
 
1951
            if (stop_index is not None and
 
1952
                len(self._partial_revision_history_cache) > stop_index):
 
1953
                break
 
1954
            if revision_id == stop_revision:
 
1955
                break
 
1956
 
2779
1957
    def _write_revision_history(self, history):
2780
1958
        """Factored out of set_revision_history.
2781
1959
 
2802
1980
        """Set the parent branch"""
2803
1981
        return self._get_config_location('parent_location')
2804
1982
 
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
1983
    def set_push_location(self, location):
2881
1984
        """See Branch.set_push_location."""
2882
1985
        self._set_config_location('push_location', location)
2915
2018
        """See Branch.get_old_bound_location"""
2916
2019
        return self._get_bound_location(False)
2917
2020
 
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
 
2021
    def set_append_revisions_only(self, enabled):
 
2022
        if enabled:
 
2023
            value = 'True'
 
2024
        else:
 
2025
            value = 'False'
 
2026
        self.get_config().set_user_option('append_revisions_only', value,
 
2027
            warn_masked=True)
2926
2028
 
2927
2029
    def _get_append_revisions_only(self):
2928
 
        return self.get_config(
2929
 
            ).get_user_option_as_bool('append_revisions_only')
 
2030
        value = self.get_config().get_user_option('append_revisions_only')
 
2031
        return value == 'True'
 
2032
 
 
2033
    def _synchronize_history(self, destination, revision_id):
 
2034
        """Synchronize last revision and revision history between branches.
 
2035
 
 
2036
        This version is most efficient when the destination is also a
 
2037
        BzrBranch6, but works for BzrBranch5, as long as the destination's
 
2038
        repository contains all the lefthand ancestors of the intended
 
2039
        last_revision.  If not, set_last_revision_info will fail.
 
2040
 
 
2041
        :param destination: The branch to copy the history into
 
2042
        :param revision_id: The revision-id to truncate history at.  May
 
2043
          be None to copy complete history.
 
2044
        """
 
2045
        source_revno, source_revision_id = self.last_revision_info()
 
2046
        if revision_id is None:
 
2047
            revno, revision_id = source_revno, source_revision_id
 
2048
        elif source_revision_id == revision_id:
 
2049
            # we know the revno without needing to walk all of history
 
2050
            revno = source_revno
 
2051
        else:
 
2052
            # To figure out the revno for a random revision, we need to build
 
2053
            # the revision history, and count its length.
 
2054
            # We don't care about the order, just how long it is.
 
2055
            # Alternatively, we could start at the current location, and count
 
2056
            # backwards. But there is no guarantee that we will find it since
 
2057
            # it may be a merged revision.
 
2058
            revno = len(list(self.repository.iter_reverse_revision_history(
 
2059
                                                                revision_id)))
 
2060
        destination.set_last_revision_info(revno, revision_id)
 
2061
 
 
2062
    def _make_tags(self):
 
2063
        return BasicTags(self)
2930
2064
 
2931
2065
    @needs_write_lock
2932
2066
    def generate_revision_history(self, revision_id, last_rev=None,
2947
2081
            raise errors.NoSuchRevision(self, revno)
2948
2082
 
2949
2083
        if history is not None:
 
2084
            assert len(history) == last_revno, 'revno/history mismatch'
2950
2085
            return history[revno - 1]
2951
2086
 
2952
2087
        index = last_revno - revno
2972
2107
        return self.revno() - index
2973
2108
 
2974
2109
 
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)
2998
 
 
2999
 
 
3000
2110
######################################################################
3001
2111
# results of operations
3002
2112
 
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):
3039
2146
        self._show_tag_conficts(to_file)
3040
2147
 
3041
2148
 
3042
 
class BranchPushResult(_Result):
 
2149
class PushResult(_Result):
3043
2150
    """Result of a Branch.push operation.
3044
2151
 
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.
 
2152
    :ivar old_revno: Revision number before push.
 
2153
    :ivar new_revno: Revision number after push.
 
2154
    :ivar old_revid: Tip revision id before push.
 
2155
    :ivar new_revid: Tip revision id after push.
 
2156
    :ivar source_branch: Source branch object.
 
2157
    :ivar master_branch: Master branch of the target, or None.
 
2158
    :ivar target_branch: Target/destination branch object.
3059
2159
    """
3060
2160
 
3061
2161
    def __int__(self):
3065
2165
    def report(self, to_file):
3066
2166
        """Write a human-readable description of the result."""
3067
2167
        if self.old_revid == self.new_revid:
3068
 
            note('No new revisions to push.')
 
2168
            to_file.write('No new revisions to push.\n')
3069
2169
        else:
3070
 
            note('Pushed up to revision %d.' % self.new_revno)
 
2170
            to_file.write('Pushed up to revision %d.\n' % self.new_revno)
3071
2171
        self._show_tag_conficts(to_file)
3072
2172
 
3073
2173
 
3079
2179
 
3080
2180
    def __init__(self, branch):
3081
2181
        self.branch = branch
3082
 
        self.errors = []
3083
2182
 
3084
2183
    def report_results(self, verbose):
3085
2184
        """Report the check results via trace.note.
3086
 
 
 
2185
        
3087
2186
        :param verbose: Requests more detailed display of what was checked,
3088
2187
            if any.
3089
2188
        """
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)
 
2189
        note('checked branch %s format %s',
 
2190
             self.branch.base,
 
2191
             self.branch._format)
3094
2192
 
3095
2193
 
3096
2194
class Converter5to6(object):
3111
2209
        new_branch.tags._set_tag_dict({})
3112
2210
 
3113
2211
        # 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())
 
2212
        new_branch.control_files.put_utf8('format',
 
2213
            format.get_format_string())
3117
2214
 
3118
2215
        # Clean up old files
3119
 
        new_branch._transport.delete('revision-history')
 
2216
        new_branch.control_files._transport.delete('revision-history')
3120
2217
        try:
3121
2218
            branch.set_parent(None)
3122
2219
        except errors.NoSuchFile:
3123
2220
            pass
3124
2221
        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)