/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: Andrew Bennetts
  • Date: 2008-07-25 06:42:08 UTC
  • mto: This revision was merged to the branch mainline in revision 3581.
  • Revision ID: andrew.bennetts@canonical.com-20080725064208-ui70gluukdypd4y9
Cherry-pick TipChangeRejected changes from pre-branch-tip-changed-hook loom.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005, 2006, 2007, 2008 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
 
18
import sys
 
19
 
 
20
from bzrlib.lazy_import import lazy_import
 
21
lazy_import(globals(), """
 
22
from itertools import chain
 
23
from bzrlib import (
 
24
        bzrdir,
 
25
        cache_utf8,
 
26
        config as _mod_config,
 
27
        debug,
 
28
        errors,
 
29
        lockdir,
 
30
        lockable_files,
 
31
        repository,
 
32
        revision as _mod_revision,
 
33
        transport,
 
34
        tsort,
 
35
        ui,
 
36
        urlutils,
 
37
        )
 
38
from bzrlib.config import BranchConfig
 
39
from bzrlib.repofmt.pack_repo import RepositoryFormatPackDevelopment1Subtree
 
40
from bzrlib.tag import (
 
41
    BasicTags,
 
42
    DisabledTags,
 
43
    )
 
44
""")
 
45
 
 
46
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
47
from bzrlib.hooks import Hooks
 
48
from bzrlib.symbol_versioning import (
 
49
    deprecated_in,
 
50
    deprecated_method,
 
51
    )
 
52
from bzrlib.trace import mutter, mutter_callsite, note, is_quiet
 
53
 
 
54
 
 
55
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
 
56
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
 
57
BZR_BRANCH_FORMAT_6 = "Bazaar Branch Format 6 (bzr 0.15)\n"
 
58
 
 
59
 
 
60
# TODO: Maybe include checks for common corruption of newlines, etc?
 
61
 
 
62
# TODO: Some operations like log might retrieve the same revisions
 
63
# repeatedly to calculate deltas.  We could perhaps have a weakref
 
64
# cache in memory to make this faster.  In general anything can be
 
65
# cached in memory between lock and unlock operations. .. nb thats
 
66
# what the transaction identity map provides
 
67
 
 
68
 
 
69
######################################################################
 
70
# branch objects
 
71
 
 
72
class Branch(object):
 
73
    """Branch holding a history of revisions.
 
74
 
 
75
    base
 
76
        Base directory/url of the branch.
 
77
 
 
78
    hooks: An instance of BranchHooks.
 
79
    """
 
80
    # this is really an instance variable - FIXME move it there
 
81
    # - RBC 20060112
 
82
    base = None
 
83
 
 
84
    # override this to set the strategy for storing tags
 
85
    def _make_tags(self):
 
86
        return DisabledTags(self)
 
87
 
 
88
    def __init__(self, *ignored, **ignored_too):
 
89
        self.tags = self._make_tags()
 
90
        self._revision_history_cache = None
 
91
        self._revision_id_to_revno_cache = None
 
92
        self._last_revision_info_cache = None
 
93
        self._open_hook()
 
94
 
 
95
    def _open_hook(self):
 
96
        """Called by init to allow simpler extension of the base class."""
 
97
 
 
98
    def break_lock(self):
 
99
        """Break a lock if one is present from another instance.
 
100
 
 
101
        Uses the ui factory to ask for confirmation if the lock may be from
 
102
        an active process.
 
103
 
 
104
        This will probe the repository for its lock as well.
 
105
        """
 
106
        self.control_files.break_lock()
 
107
        self.repository.break_lock()
 
108
        master = self.get_master_branch()
 
109
        if master is not None:
 
110
            master.break_lock()
 
111
 
 
112
    @staticmethod
 
113
    def open(base, _unsupported=False, possible_transports=None):
 
114
        """Open the branch rooted at base.
 
115
 
 
116
        For instance, if the branch is at URL/.bzr/branch,
 
117
        Branch.open(URL) -> a Branch instance.
 
118
        """
 
119
        control = bzrdir.BzrDir.open(base, _unsupported,
 
120
                                     possible_transports=possible_transports)
 
121
        return control.open_branch(_unsupported)
 
122
 
 
123
    @staticmethod
 
124
    def open_from_transport(transport, _unsupported=False):
 
125
        """Open the branch rooted at transport"""
 
126
        control = bzrdir.BzrDir.open_from_transport(transport, _unsupported)
 
127
        return control.open_branch(_unsupported)
 
128
 
 
129
    @staticmethod
 
130
    def open_containing(url, possible_transports=None):
 
131
        """Open an existing branch which contains url.
 
132
        
 
133
        This probes for a branch at url, and searches upwards from there.
 
134
 
 
135
        Basically we keep looking up until we find the control directory or
 
136
        run into the root.  If there isn't one, raises NotBranchError.
 
137
        If there is one and it is either an unrecognised format or an unsupported 
 
138
        format, UnknownFormatError or UnsupportedFormatError are raised.
 
139
        If there is one, it is returned, along with the unused portion of url.
 
140
        """
 
141
        control, relpath = bzrdir.BzrDir.open_containing(url,
 
142
                                                         possible_transports)
 
143
        return control.open_branch(), relpath
 
144
 
 
145
    def get_config(self):
 
146
        return BranchConfig(self)
 
147
 
 
148
    def _get_nick(self):
 
149
        return self.get_config().get_nickname()
 
150
 
 
151
    def _set_nick(self, nick):
 
152
        self.get_config().set_user_option('nickname', nick, warn_masked=True)
 
153
 
 
154
    nick = property(_get_nick, _set_nick)
 
155
 
 
156
    def is_locked(self):
 
157
        raise NotImplementedError(self.is_locked)
 
158
 
 
159
    def lock_write(self):
 
160
        raise NotImplementedError(self.lock_write)
 
161
 
 
162
    def lock_read(self):
 
163
        raise NotImplementedError(self.lock_read)
 
164
 
 
165
    def unlock(self):
 
166
        raise NotImplementedError(self.unlock)
 
167
 
 
168
    def peek_lock_mode(self):
 
169
        """Return lock mode for the Branch: 'r', 'w' or None"""
 
170
        raise NotImplementedError(self.peek_lock_mode)
 
171
 
 
172
    def get_physical_lock_status(self):
 
173
        raise NotImplementedError(self.get_physical_lock_status)
 
174
 
 
175
    @needs_read_lock
 
176
    def get_revision_id_to_revno_map(self):
 
177
        """Return the revision_id => dotted revno map.
 
178
 
 
179
        This will be regenerated on demand, but will be cached.
 
180
 
 
181
        :return: A dictionary mapping revision_id => dotted revno.
 
182
            This dictionary should not be modified by the caller.
 
183
        """
 
184
        if self._revision_id_to_revno_cache is not None:
 
185
            mapping = self._revision_id_to_revno_cache
 
186
        else:
 
187
            mapping = self._gen_revno_map()
 
188
            self._cache_revision_id_to_revno(mapping)
 
189
        # TODO: jam 20070417 Since this is being cached, should we be returning
 
190
        #       a copy?
 
191
        # I would rather not, and instead just declare that users should not
 
192
        # modify the return value.
 
193
        return mapping
 
194
 
 
195
    def _gen_revno_map(self):
 
196
        """Create a new mapping from revision ids to dotted revnos.
 
197
 
 
198
        Dotted revnos are generated based on the current tip in the revision
 
199
        history.
 
200
        This is the worker function for get_revision_id_to_revno_map, which
 
201
        just caches the return value.
 
202
 
 
203
        :return: A dictionary mapping revision_id => dotted revno.
 
204
        """
 
205
        last_revision = self.last_revision()
 
206
        revision_graph = repository._old_get_graph(self.repository,
 
207
            last_revision)
 
208
        merge_sorted_revisions = tsort.merge_sort(
 
209
            revision_graph,
 
210
            last_revision,
 
211
            None,
 
212
            generate_revno=True)
 
213
        revision_id_to_revno = dict((rev_id, revno)
 
214
                                    for seq_num, rev_id, depth, revno, end_of_merge
 
215
                                     in merge_sorted_revisions)
 
216
        return revision_id_to_revno
 
217
 
 
218
    def leave_lock_in_place(self):
 
219
        """Tell this branch object not to release the physical lock when this
 
220
        object is unlocked.
 
221
        
 
222
        If lock_write doesn't return a token, then this method is not supported.
 
223
        """
 
224
        self.control_files.leave_in_place()
 
225
 
 
226
    def dont_leave_lock_in_place(self):
 
227
        """Tell this branch object to release the physical lock when this
 
228
        object is unlocked, even if it didn't originally acquire it.
 
229
 
 
230
        If lock_write doesn't return a token, then this method is not supported.
 
231
        """
 
232
        self.control_files.dont_leave_in_place()
 
233
 
 
234
    @deprecated_method(deprecated_in((0, 16, 0)))
 
235
    def abspath(self, name):
 
236
        """Return absolute filename for something in the branch
 
237
        
 
238
        XXX: Robert Collins 20051017 what is this used for? why is it a branch
 
239
        method and not a tree method.
 
240
        """
 
241
        raise NotImplementedError(self.abspath)
 
242
 
 
243
    def bind(self, other):
 
244
        """Bind the local branch the other branch.
 
245
 
 
246
        :param other: The branch to bind to
 
247
        :type other: Branch
 
248
        """
 
249
        raise errors.UpgradeRequired(self.base)
 
250
 
 
251
    @needs_write_lock
 
252
    def fetch(self, from_branch, last_revision=None, pb=None):
 
253
        """Copy revisions from from_branch into this branch.
 
254
 
 
255
        :param from_branch: Where to copy from.
 
256
        :param last_revision: What revision to stop at (None for at the end
 
257
                              of the branch.
 
258
        :param pb: An optional progress bar to use.
 
259
 
 
260
        Returns the copied revision count and the failed revisions in a tuple:
 
261
        (copied, failures).
 
262
        """
 
263
        if self.base == from_branch.base:
 
264
            return (0, [])
 
265
        if pb is None:
 
266
            nested_pb = ui.ui_factory.nested_progress_bar()
 
267
            pb = nested_pb
 
268
        else:
 
269
            nested_pb = None
 
270
 
 
271
        from_branch.lock_read()
 
272
        try:
 
273
            if last_revision is None:
 
274
                pb.update('get source history')
 
275
                last_revision = from_branch.last_revision()
 
276
                last_revision = _mod_revision.ensure_null(last_revision)
 
277
            return self.repository.fetch(from_branch.repository,
 
278
                                         revision_id=last_revision,
 
279
                                         pb=nested_pb)
 
280
        finally:
 
281
            if nested_pb is not None:
 
282
                nested_pb.finished()
 
283
            from_branch.unlock()
 
284
 
 
285
    def get_bound_location(self):
 
286
        """Return the URL of the branch we are bound to.
 
287
 
 
288
        Older format branches cannot bind, please be sure to use a metadir
 
289
        branch.
 
290
        """
 
291
        return None
 
292
    
 
293
    def get_old_bound_location(self):
 
294
        """Return the URL of the branch we used to be bound to
 
295
        """
 
296
        raise errors.UpgradeRequired(self.base)
 
297
 
 
298
    def get_commit_builder(self, parents, config=None, timestamp=None, 
 
299
                           timezone=None, committer=None, revprops=None, 
 
300
                           revision_id=None):
 
301
        """Obtain a CommitBuilder for this branch.
 
302
        
 
303
        :param parents: Revision ids of the parents of the new revision.
 
304
        :param config: Optional configuration to use.
 
305
        :param timestamp: Optional timestamp recorded for commit.
 
306
        :param timezone: Optional timezone for timestamp.
 
307
        :param committer: Optional committer to set for commit.
 
308
        :param revprops: Optional dictionary of revision properties.
 
309
        :param revision_id: Optional revision id.
 
310
        """
 
311
 
 
312
        if config is None:
 
313
            config = self.get_config()
 
314
        
 
315
        return self.repository.get_commit_builder(self, parents, config,
 
316
            timestamp, timezone, committer, revprops, revision_id)
 
317
 
 
318
    def get_master_branch(self, possible_transports=None):
 
319
        """Return the branch we are bound to.
 
320
        
 
321
        :return: Either a Branch, or None
 
322
        """
 
323
        return None
 
324
 
 
325
    def get_revision_delta(self, revno):
 
326
        """Return the delta for one revision.
 
327
 
 
328
        The delta is relative to its mainline predecessor, or the
 
329
        empty tree for revision 1.
 
330
        """
 
331
        rh = self.revision_history()
 
332
        if not (1 <= revno <= len(rh)):
 
333
            raise errors.InvalidRevisionNumber(revno)
 
334
        return self.repository.get_revision_delta(rh[revno-1])
 
335
 
 
336
    def get_stacked_on_url(self):
 
337
        """Get the URL this branch is stacked against.
 
338
 
 
339
        :raises NotStacked: If the branch is not stacked.
 
340
        :raises UnstackableBranchFormat: If the branch does not support
 
341
            stacking.
 
342
        """
 
343
        raise NotImplementedError(self.get_stacked_on_url)
 
344
 
 
345
    def print_file(self, file, revision_id):
 
346
        """Print `file` to stdout."""
 
347
        raise NotImplementedError(self.print_file)
 
348
 
 
349
    def set_revision_history(self, rev_history):
 
350
        raise NotImplementedError(self.set_revision_history)
 
351
 
 
352
    def set_stacked_on_url(self, url):
 
353
        """Set the URL this branch is stacked against.
 
354
 
 
355
        :raises UnstackableBranchFormat: If the branch does not support
 
356
            stacking.
 
357
        :raises UnstackableRepositoryFormat: If the repository does not support
 
358
            stacking.
 
359
        """
 
360
        raise NotImplementedError(self.set_stacked_on_url)
 
361
 
 
362
    def _cache_revision_history(self, rev_history):
 
363
        """Set the cached revision history to rev_history.
 
364
 
 
365
        The revision_history method will use this cache to avoid regenerating
 
366
        the revision history.
 
367
 
 
368
        This API is semi-public; it only for use by subclasses, all other code
 
369
        should consider it to be private.
 
370
        """
 
371
        self._revision_history_cache = rev_history
 
372
 
 
373
    def _cache_revision_id_to_revno(self, revision_id_to_revno):
 
374
        """Set the cached revision_id => revno map to revision_id_to_revno.
 
375
 
 
376
        This API is semi-public; it only for use by subclasses, all other code
 
377
        should consider it to be private.
 
378
        """
 
379
        self._revision_id_to_revno_cache = revision_id_to_revno
 
380
 
 
381
    def _clear_cached_state(self):
 
382
        """Clear any cached data on this branch, e.g. cached revision history.
 
383
 
 
384
        This means the next call to revision_history will need to call
 
385
        _gen_revision_history.
 
386
 
 
387
        This API is semi-public; it only for use by subclasses, all other code
 
388
        should consider it to be private.
 
389
        """
 
390
        self._revision_history_cache = None
 
391
        self._revision_id_to_revno_cache = None
 
392
        self._last_revision_info_cache = None
 
393
 
 
394
    def _gen_revision_history(self):
 
395
        """Return sequence of revision hashes on to this branch.
 
396
        
 
397
        Unlike revision_history, this method always regenerates or rereads the
 
398
        revision history, i.e. it does not cache the result, so repeated calls
 
399
        may be expensive.
 
400
 
 
401
        Concrete subclasses should override this instead of revision_history so
 
402
        that subclasses do not need to deal with caching logic.
 
403
        
 
404
        This API is semi-public; it only for use by subclasses, all other code
 
405
        should consider it to be private.
 
406
        """
 
407
        raise NotImplementedError(self._gen_revision_history)
 
408
 
 
409
    @needs_read_lock
 
410
    def revision_history(self):
 
411
        """Return sequence of revision ids on this branch.
 
412
        
 
413
        This method will cache the revision history for as long as it is safe to
 
414
        do so.
 
415
        """
 
416
        if 'evil' in debug.debug_flags:
 
417
            mutter_callsite(3, "revision_history scales with history.")
 
418
        if self._revision_history_cache is not None:
 
419
            history = self._revision_history_cache
 
420
        else:
 
421
            history = self._gen_revision_history()
 
422
            self._cache_revision_history(history)
 
423
        return list(history)
 
424
 
 
425
    def revno(self):
 
426
        """Return current revision number for this branch.
 
427
 
 
428
        That is equivalent to the number of revisions committed to
 
429
        this branch.
 
430
        """
 
431
        return self.last_revision_info()[0]
 
432
 
 
433
    def unbind(self):
 
434
        """Older format branches cannot bind or unbind."""
 
435
        raise errors.UpgradeRequired(self.base)
 
436
 
 
437
    def set_append_revisions_only(self, enabled):
 
438
        """Older format branches are never restricted to append-only"""
 
439
        raise errors.UpgradeRequired(self.base)
 
440
 
 
441
    def last_revision(self):
 
442
        """Return last revision id, or NULL_REVISION."""
 
443
        return self.last_revision_info()[1]
 
444
 
 
445
    @needs_read_lock
 
446
    def last_revision_info(self):
 
447
        """Return information about the last revision.
 
448
 
 
449
        :return: A tuple (revno, revision_id).
 
450
        """
 
451
        if self._last_revision_info_cache is None:
 
452
            self._last_revision_info_cache = self._last_revision_info()
 
453
        return self._last_revision_info_cache
 
454
 
 
455
    def _last_revision_info(self):
 
456
        rh = self.revision_history()
 
457
        revno = len(rh)
 
458
        if revno:
 
459
            return (revno, rh[-1])
 
460
        else:
 
461
            return (0, _mod_revision.NULL_REVISION)
 
462
 
 
463
    @deprecated_method(deprecated_in((1, 6, 0)))
 
464
    def missing_revisions(self, other, stop_revision=None):
 
465
        """Return a list of new revisions that would perfectly fit.
 
466
        
 
467
        If self and other have not diverged, return a list of the revisions
 
468
        present in other, but missing from self.
 
469
        """
 
470
        self_history = self.revision_history()
 
471
        self_len = len(self_history)
 
472
        other_history = other.revision_history()
 
473
        other_len = len(other_history)
 
474
        common_index = min(self_len, other_len) -1
 
475
        if common_index >= 0 and \
 
476
            self_history[common_index] != other_history[common_index]:
 
477
            raise errors.DivergedBranches(self, other)
 
478
 
 
479
        if stop_revision is None:
 
480
            stop_revision = other_len
 
481
        else:
 
482
            if stop_revision > other_len:
 
483
                raise errors.NoSuchRevision(self, stop_revision)
 
484
        return other_history[self_len:stop_revision]
 
485
 
 
486
    @needs_write_lock
 
487
    def update_revisions(self, other, stop_revision=None, overwrite=False,
 
488
                         graph=None):
 
489
        """Pull in new perfect-fit revisions.
 
490
 
 
491
        :param other: Another Branch to pull from
 
492
        :param stop_revision: Updated until the given revision
 
493
        :param overwrite: Always set the branch pointer, rather than checking
 
494
            to see if it is a proper descendant.
 
495
        :param graph: A Graph object that can be used to query history
 
496
            information. This can be None.
 
497
        :return: None
 
498
        """
 
499
        other.lock_read()
 
500
        try:
 
501
            other_revno, other_last_revision = other.last_revision_info()
 
502
            stop_revno = None # unknown
 
503
            if stop_revision is None:
 
504
                stop_revision = other_last_revision
 
505
                if _mod_revision.is_null(stop_revision):
 
506
                    # if there are no commits, we're done.
 
507
                    return
 
508
                stop_revno = other_revno
 
509
 
 
510
            # what's the current last revision, before we fetch [and change it
 
511
            # possibly]
 
512
            last_rev = _mod_revision.ensure_null(self.last_revision())
 
513
            # we fetch here so that we don't process data twice in the common
 
514
            # case of having something to pull, and so that the check for 
 
515
            # already merged can operate on the just fetched graph, which will
 
516
            # be cached in memory.
 
517
            self.fetch(other, stop_revision)
 
518
            # Check to see if one is an ancestor of the other
 
519
            if not overwrite:
 
520
                if graph is None:
 
521
                    graph = self.repository.get_graph()
 
522
                if self._check_if_descendant_or_diverged(
 
523
                        stop_revision, last_rev, graph, other):
 
524
                    # stop_revision is a descendant of last_rev, but we aren't
 
525
                    # overwriting, so we're done.
 
526
                    return
 
527
            if stop_revno is None:
 
528
                if graph is None:
 
529
                    graph = self.repository.get_graph()
 
530
                this_revno, this_last_revision = self.last_revision_info()
 
531
                stop_revno = graph.find_distance_to_null(stop_revision,
 
532
                                [(other_last_revision, other_revno),
 
533
                                 (this_last_revision, this_revno)])
 
534
            self.set_last_revision_info(stop_revno, stop_revision)
 
535
        finally:
 
536
            other.unlock()
 
537
 
 
538
    def revision_id_to_revno(self, revision_id):
 
539
        """Given a revision id, return its revno"""
 
540
        if _mod_revision.is_null(revision_id):
 
541
            return 0
 
542
        history = self.revision_history()
 
543
        try:
 
544
            return history.index(revision_id) + 1
 
545
        except ValueError:
 
546
            raise errors.NoSuchRevision(self, revision_id)
 
547
 
 
548
    def get_rev_id(self, revno, history=None):
 
549
        """Find the revision id of the specified revno."""
 
550
        if revno == 0:
 
551
            return _mod_revision.NULL_REVISION
 
552
        if history is None:
 
553
            history = self.revision_history()
 
554
        if revno <= 0 or revno > len(history):
 
555
            raise errors.NoSuchRevision(self, revno)
 
556
        return history[revno - 1]
 
557
 
 
558
    def pull(self, source, overwrite=False, stop_revision=None,
 
559
             possible_transports=None, _override_hook_target=None):
 
560
        """Mirror source into this branch.
 
561
 
 
562
        This branch is considered to be 'local', having low latency.
 
563
 
 
564
        :returns: PullResult instance
 
565
        """
 
566
        raise NotImplementedError(self.pull)
 
567
 
 
568
    def push(self, target, overwrite=False, stop_revision=None):
 
569
        """Mirror this branch into target.
 
570
 
 
571
        This branch is considered to be 'local', having low latency.
 
572
        """
 
573
        raise NotImplementedError(self.push)
 
574
 
 
575
    def basis_tree(self):
 
576
        """Return `Tree` object for last revision."""
 
577
        return self.repository.revision_tree(self.last_revision())
 
578
 
 
579
    def rename_one(self, from_rel, to_rel):
 
580
        """Rename one file.
 
581
 
 
582
        This can change the directory or the filename or both.
 
583
        """
 
584
        raise NotImplementedError(self.rename_one)
 
585
 
 
586
    def move(self, from_paths, to_name):
 
587
        """Rename files.
 
588
 
 
589
        to_name must exist as a versioned directory.
 
590
 
 
591
        If to_name exists and is a directory, the files are moved into
 
592
        it, keeping their old names.  If it is a directory, 
 
593
 
 
594
        Note that to_name is only the last component of the new name;
 
595
        this doesn't change the directory.
 
596
 
 
597
        This returns a list of (from_path, to_path) pairs for each
 
598
        entry that is moved.
 
599
        """
 
600
        raise NotImplementedError(self.move)
 
601
 
 
602
    def get_parent(self):
 
603
        """Return the parent location of the branch.
 
604
 
 
605
        This is the default location for push/pull/missing.  The usual
 
606
        pattern is that the user can override it by specifying a
 
607
        location.
 
608
        """
 
609
        raise NotImplementedError(self.get_parent)
 
610
 
 
611
    def _set_config_location(self, name, url, config=None,
 
612
                             make_relative=False):
 
613
        if config is None:
 
614
            config = self.get_config()
 
615
        if url is None:
 
616
            url = ''
 
617
        elif make_relative:
 
618
            url = urlutils.relative_url(self.base, url)
 
619
        config.set_user_option(name, url, warn_masked=True)
 
620
 
 
621
    def _get_config_location(self, name, config=None):
 
622
        if config is None:
 
623
            config = self.get_config()
 
624
        location = config.get_user_option(name)
 
625
        if location == '':
 
626
            location = None
 
627
        return location
 
628
 
 
629
    def get_submit_branch(self):
 
630
        """Return the submit location of the branch.
 
631
 
 
632
        This is the default location for bundle.  The usual
 
633
        pattern is that the user can override it by specifying a
 
634
        location.
 
635
        """
 
636
        return self.get_config().get_user_option('submit_branch')
 
637
 
 
638
    def set_submit_branch(self, location):
 
639
        """Return the submit location of the branch.
 
640
 
 
641
        This is the default location for bundle.  The usual
 
642
        pattern is that the user can override it by specifying a
 
643
        location.
 
644
        """
 
645
        self.get_config().set_user_option('submit_branch', location,
 
646
            warn_masked=True)
 
647
 
 
648
    def get_public_branch(self):
 
649
        """Return the public location of the branch.
 
650
 
 
651
        This is is used by merge directives.
 
652
        """
 
653
        return self._get_config_location('public_branch')
 
654
 
 
655
    def set_public_branch(self, location):
 
656
        """Return the submit location of the branch.
 
657
 
 
658
        This is the default location for bundle.  The usual
 
659
        pattern is that the user can override it by specifying a
 
660
        location.
 
661
        """
 
662
        self._set_config_location('public_branch', location)
 
663
 
 
664
    def get_push_location(self):
 
665
        """Return the None or the location to push this branch to."""
 
666
        push_loc = self.get_config().get_user_option('push_location')
 
667
        return push_loc
 
668
 
 
669
    def set_push_location(self, location):
 
670
        """Set a new push location for this branch."""
 
671
        raise NotImplementedError(self.set_push_location)
 
672
 
 
673
    def set_parent(self, url):
 
674
        raise NotImplementedError(self.set_parent)
 
675
 
 
676
    @needs_write_lock
 
677
    def update(self):
 
678
        """Synchronise this branch with the master branch if any. 
 
679
 
 
680
        :return: None or the last_revision pivoted out during the update.
 
681
        """
 
682
        return None
 
683
 
 
684
    def check_revno(self, revno):
 
685
        """\
 
686
        Check whether a revno corresponds to any revision.
 
687
        Zero (the NULL revision) is considered valid.
 
688
        """
 
689
        if revno != 0:
 
690
            self.check_real_revno(revno)
 
691
            
 
692
    def check_real_revno(self, revno):
 
693
        """\
 
694
        Check whether a revno corresponds to a real revision.
 
695
        Zero (the NULL revision) is considered invalid
 
696
        """
 
697
        if revno < 1 or revno > self.revno():
 
698
            raise errors.InvalidRevisionNumber(revno)
 
699
 
 
700
    @needs_read_lock
 
701
    def clone(self, to_bzrdir, revision_id=None):
 
702
        """Clone this branch into to_bzrdir preserving all semantic values.
 
703
        
 
704
        revision_id: if not None, the revision history in the new branch will
 
705
                     be truncated to end with revision_id.
 
706
        """
 
707
        result = self._format.initialize(to_bzrdir)
 
708
        self.copy_content_into(result, revision_id=revision_id)
 
709
        return  result
 
710
 
 
711
    @needs_read_lock
 
712
    def sprout(self, to_bzrdir, revision_id=None):
 
713
        """Create a new line of development from the branch, into to_bzrdir.
 
714
        
 
715
        revision_id: if not None, the revision history in the new branch will
 
716
                     be truncated to end with revision_id.
 
717
        """
 
718
        result = self._format.initialize(to_bzrdir)
 
719
        self.copy_content_into(result, revision_id=revision_id)
 
720
        result.set_parent(self.bzrdir.root_transport.base)
 
721
        return result
 
722
 
 
723
    def _synchronize_history(self, destination, revision_id):
 
724
        """Synchronize last revision and revision history between branches.
 
725
 
 
726
        This version is most efficient when the destination is also a
 
727
        BzrBranch5, but works for BzrBranch6 as long as the revision
 
728
        history is the true lefthand parent history, and all of the revisions
 
729
        are in the destination's repository.  If not, set_revision_history
 
730
        will fail.
 
731
 
 
732
        :param destination: The branch to copy the history into
 
733
        :param revision_id: The revision-id to truncate history at.  May
 
734
          be None to copy complete history.
 
735
        """
 
736
        if revision_id == _mod_revision.NULL_REVISION:
 
737
            new_history = []
 
738
        new_history = self.revision_history()
 
739
        if revision_id is not None and new_history != []:
 
740
            try:
 
741
                new_history = new_history[:new_history.index(revision_id) + 1]
 
742
            except ValueError:
 
743
                rev = self.repository.get_revision(revision_id)
 
744
                new_history = rev.get_history(self.repository)[1:]
 
745
        destination.set_revision_history(new_history)
 
746
 
 
747
    @needs_read_lock
 
748
    def copy_content_into(self, destination, revision_id=None):
 
749
        """Copy the content of self into destination.
 
750
 
 
751
        revision_id: if not None, the revision history in the new branch will
 
752
                     be truncated to end with revision_id.
 
753
        """
 
754
        self._synchronize_history(destination, revision_id)
 
755
        try:
 
756
            parent = self.get_parent()
 
757
        except errors.InaccessibleParent, e:
 
758
            mutter('parent was not accessible to copy: %s', e)
 
759
        else:
 
760
            if parent:
 
761
                destination.set_parent(parent)
 
762
        self.tags.merge_to(destination.tags)
 
763
 
 
764
    @needs_read_lock
 
765
    def check(self):
 
766
        """Check consistency of the branch.
 
767
 
 
768
        In particular this checks that revisions given in the revision-history
 
769
        do actually match up in the revision graph, and that they're all 
 
770
        present in the repository.
 
771
        
 
772
        Callers will typically also want to check the repository.
 
773
 
 
774
        :return: A BranchCheckResult.
 
775
        """
 
776
        mainline_parent_id = None
 
777
        last_revno, last_revision_id = self.last_revision_info()
 
778
        real_rev_history = list(self.repository.iter_reverse_revision_history(
 
779
                                last_revision_id))
 
780
        real_rev_history.reverse()
 
781
        if len(real_rev_history) != last_revno:
 
782
            raise errors.BzrCheckError('revno does not match len(mainline)'
 
783
                ' %s != %s' % (last_revno, len(real_rev_history)))
 
784
        # TODO: We should probably also check that real_rev_history actually
 
785
        #       matches self.revision_history()
 
786
        for revision_id in real_rev_history:
 
787
            try:
 
788
                revision = self.repository.get_revision(revision_id)
 
789
            except errors.NoSuchRevision, e:
 
790
                raise errors.BzrCheckError("mainline revision {%s} not in repository"
 
791
                            % revision_id)
 
792
            # In general the first entry on the revision history has no parents.
 
793
            # But it's not illegal for it to have parents listed; this can happen
 
794
            # in imports from Arch when the parents weren't reachable.
 
795
            if mainline_parent_id is not None:
 
796
                if mainline_parent_id not in revision.parent_ids:
 
797
                    raise errors.BzrCheckError("previous revision {%s} not listed among "
 
798
                                        "parents of {%s}"
 
799
                                        % (mainline_parent_id, revision_id))
 
800
            mainline_parent_id = revision_id
 
801
        return BranchCheckResult(self)
 
802
 
 
803
    def _get_checkout_format(self):
 
804
        """Return the most suitable metadir for a checkout of this branch.
 
805
        Weaves are used if this branch's repository uses weaves.
 
806
        """
 
807
        if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):
 
808
            from bzrlib.repofmt import weaverepo
 
809
            format = bzrdir.BzrDirMetaFormat1()
 
810
            format.repository_format = weaverepo.RepositoryFormat7()
 
811
        else:
 
812
            format = self.repository.bzrdir.checkout_metadir()
 
813
            format.set_branch_format(self._format)
 
814
        return format
 
815
 
 
816
    def create_checkout(self, to_location, revision_id=None,
 
817
                        lightweight=False, accelerator_tree=None,
 
818
                        hardlink=False):
 
819
        """Create a checkout of a branch.
 
820
        
 
821
        :param to_location: The url to produce the checkout at
 
822
        :param revision_id: The revision to check out
 
823
        :param lightweight: If True, produce a lightweight checkout, otherwise,
 
824
        produce a bound branch (heavyweight checkout)
 
825
        :param accelerator_tree: A tree which can be used for retrieving file
 
826
            contents more quickly than the revision tree, i.e. a workingtree.
 
827
            The revision tree will be used for cases where accelerator_tree's
 
828
            content is different.
 
829
        :param hardlink: If true, hard-link files from accelerator_tree,
 
830
            where possible.
 
831
        :return: The tree of the created checkout
 
832
        """
 
833
        t = transport.get_transport(to_location)
 
834
        t.ensure_base()
 
835
        if lightweight:
 
836
            format = self._get_checkout_format()
 
837
            checkout = format.initialize_on_transport(t)
 
838
            from_branch = BranchReferenceFormat().initialize(checkout, self)
 
839
        else:
 
840
            format = self._get_checkout_format()
 
841
            checkout_branch = bzrdir.BzrDir.create_branch_convenience(
 
842
                to_location, force_new_tree=False, format=format)
 
843
            checkout = checkout_branch.bzrdir
 
844
            checkout_branch.bind(self)
 
845
            # pull up to the specified revision_id to set the initial 
 
846
            # branch tip correctly, and seed it with history.
 
847
            checkout_branch.pull(self, stop_revision=revision_id)
 
848
            from_branch=None
 
849
        tree = checkout.create_workingtree(revision_id,
 
850
                                           from_branch=from_branch,
 
851
                                           accelerator_tree=accelerator_tree,
 
852
                                           hardlink=hardlink)
 
853
        basis_tree = tree.basis_tree()
 
854
        basis_tree.lock_read()
 
855
        try:
 
856
            for path, file_id in basis_tree.iter_references():
 
857
                reference_parent = self.reference_parent(file_id, path)
 
858
                reference_parent.create_checkout(tree.abspath(path),
 
859
                    basis_tree.get_reference_revision(file_id, path),
 
860
                    lightweight)
 
861
        finally:
 
862
            basis_tree.unlock()
 
863
        return tree
 
864
 
 
865
    @needs_write_lock
 
866
    def reconcile(self, thorough=True):
 
867
        """Make sure the data stored in this branch is consistent."""
 
868
        from bzrlib.reconcile import BranchReconciler
 
869
        reconciler = BranchReconciler(self, thorough=thorough)
 
870
        reconciler.reconcile()
 
871
        return reconciler
 
872
 
 
873
    def reference_parent(self, file_id, path):
 
874
        """Return the parent branch for a tree-reference file_id
 
875
        :param file_id: The file_id of the tree reference
 
876
        :param path: The path of the file_id in the tree
 
877
        :return: A branch associated with the file_id
 
878
        """
 
879
        # FIXME should provide multiple branches, based on config
 
880
        return Branch.open(self.bzrdir.root_transport.clone(path).base)
 
881
 
 
882
    def supports_tags(self):
 
883
        return self._format.supports_tags()
 
884
 
 
885
    def _check_if_descendant_or_diverged(self, revision_a, revision_b, graph,
 
886
                                         other_branch):
 
887
        """Ensure that revision_b is a descendant of revision_a.
 
888
 
 
889
        This is a helper function for update_revisions.
 
890
        
 
891
        :raises: DivergedBranches if revision_b has diverged from revision_a.
 
892
        :returns: True if revision_b is a descendant of revision_a.
 
893
        """
 
894
        relation = self._revision_relations(revision_a, revision_b, graph)
 
895
        if relation == 'b_descends_from_a':
 
896
            return True
 
897
        elif relation == 'diverged':
 
898
            raise errors.DivergedBranches(self, other_branch)
 
899
        elif relation == 'a_descends_from_b':
 
900
            return False
 
901
        else:
 
902
            raise AssertionError("invalid relation: %r" % (relation,))
 
903
 
 
904
    def _revision_relations(self, revision_a, revision_b, graph):
 
905
        """Determine the relationship between two revisions.
 
906
        
 
907
        :returns: One of: 'a_descends_from_b', 'b_descends_from_a', 'diverged'
 
908
        """
 
909
        heads = graph.heads([revision_a, revision_b])
 
910
        if heads == set([revision_b]):
 
911
            return 'b_descends_from_a'
 
912
        elif heads == set([revision_a, revision_b]):
 
913
            # These branches have diverged
 
914
            return 'diverged'
 
915
        elif heads == set([revision_a]):
 
916
            return 'a_descends_from_b'
 
917
        else:
 
918
            raise AssertionError("invalid heads: %r" % (heads,))
 
919
 
 
920
 
 
921
class BranchFormat(object):
 
922
    """An encapsulation of the initialization and open routines for a format.
 
923
 
 
924
    Formats provide three things:
 
925
     * An initialization routine,
 
926
     * a format string,
 
927
     * an open routine.
 
928
 
 
929
    Formats are placed in an dict by their format string for reference 
 
930
    during branch opening. Its not required that these be instances, they
 
931
    can be classes themselves with class methods - it simply depends on 
 
932
    whether state is needed for a given format or not.
 
933
 
 
934
    Once a format is deprecated, just deprecate the initialize and open
 
935
    methods on the format class. Do not deprecate the object, as the 
 
936
    object will be created every time regardless.
 
937
    """
 
938
 
 
939
    _default_format = None
 
940
    """The default format used for new branches."""
 
941
 
 
942
    _formats = {}
 
943
    """The known formats."""
 
944
 
 
945
    def __eq__(self, other):
 
946
        return self.__class__ is other.__class__
 
947
 
 
948
    def __ne__(self, other):
 
949
        return not (self == other)
 
950
 
 
951
    @classmethod
 
952
    def find_format(klass, a_bzrdir):
 
953
        """Return the format for the branch object in a_bzrdir."""
 
954
        try:
 
955
            transport = a_bzrdir.get_branch_transport(None)
 
956
            format_string = transport.get("format").read()
 
957
            return klass._formats[format_string]
 
958
        except errors.NoSuchFile:
 
959
            raise errors.NotBranchError(path=transport.base)
 
960
        except KeyError:
 
961
            raise errors.UnknownFormatError(format=format_string, kind='branch')
 
962
 
 
963
    @classmethod
 
964
    def get_default_format(klass):
 
965
        """Return the current default format."""
 
966
        return klass._default_format
 
967
 
 
968
    def get_reference(self, a_bzrdir):
 
969
        """Get the target reference of the branch in a_bzrdir.
 
970
 
 
971
        format probing must have been completed before calling
 
972
        this method - it is assumed that the format of the branch
 
973
        in a_bzrdir is correct.
 
974
 
 
975
        :param a_bzrdir: The bzrdir to get the branch data from.
 
976
        :return: None if the branch is not a reference branch.
 
977
        """
 
978
        return None
 
979
 
 
980
    @classmethod
 
981
    def set_reference(self, a_bzrdir, to_branch):
 
982
        """Set the target reference of the branch in a_bzrdir.
 
983
 
 
984
        format probing must have been completed before calling
 
985
        this method - it is assumed that the format of the branch
 
986
        in a_bzrdir is correct.
 
987
 
 
988
        :param a_bzrdir: The bzrdir to set the branch reference for.
 
989
        :param to_branch: branch that the checkout is to reference
 
990
        """
 
991
        raise NotImplementedError(self.set_reference)
 
992
 
 
993
    def get_format_string(self):
 
994
        """Return the ASCII format string that identifies this format."""
 
995
        raise NotImplementedError(self.get_format_string)
 
996
 
 
997
    def get_format_description(self):
 
998
        """Return the short format description for this format."""
 
999
        raise NotImplementedError(self.get_format_description)
 
1000
 
 
1001
    def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
 
1002
                           set_format=True):
 
1003
        """Initialize a branch in a bzrdir, with specified files
 
1004
 
 
1005
        :param a_bzrdir: The bzrdir to initialize the branch in
 
1006
        :param utf8_files: The files to create as a list of
 
1007
            (filename, content) tuples
 
1008
        :param set_format: If True, set the format with
 
1009
            self.get_format_string.  (BzrBranch4 has its format set
 
1010
            elsewhere)
 
1011
        :return: a branch in this format
 
1012
        """
 
1013
        mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
 
1014
        branch_transport = a_bzrdir.get_branch_transport(self)
 
1015
        lock_map = {
 
1016
            'metadir': ('lock', lockdir.LockDir),
 
1017
            'branch4': ('branch-lock', lockable_files.TransportLock),
 
1018
        }
 
1019
        lock_name, lock_class = lock_map[lock_type]
 
1020
        control_files = lockable_files.LockableFiles(branch_transport,
 
1021
            lock_name, lock_class)
 
1022
        control_files.create_lock()
 
1023
        control_files.lock_write()
 
1024
        if set_format:
 
1025
            utf8_files += [('format', self.get_format_string())]
 
1026
        try:
 
1027
            for (filename, content) in utf8_files:
 
1028
                branch_transport.put_bytes(
 
1029
                    filename, content,
 
1030
                    mode=a_bzrdir._get_file_mode())
 
1031
        finally:
 
1032
            control_files.unlock()
 
1033
        return self.open(a_bzrdir, _found=True)
 
1034
 
 
1035
    def initialize(self, a_bzrdir):
 
1036
        """Create a branch of this format in a_bzrdir."""
 
1037
        raise NotImplementedError(self.initialize)
 
1038
 
 
1039
    def is_supported(self):
 
1040
        """Is this format supported?
 
1041
 
 
1042
        Supported formats can be initialized and opened.
 
1043
        Unsupported formats may not support initialization or committing or 
 
1044
        some other features depending on the reason for not being supported.
 
1045
        """
 
1046
        return True
 
1047
 
 
1048
    def open(self, a_bzrdir, _found=False):
 
1049
        """Return the branch object for a_bzrdir
 
1050
 
 
1051
        _found is a private parameter, do not use it. It is used to indicate
 
1052
               if format probing has already be done.
 
1053
        """
 
1054
        raise NotImplementedError(self.open)
 
1055
 
 
1056
    @classmethod
 
1057
    def register_format(klass, format):
 
1058
        klass._formats[format.get_format_string()] = format
 
1059
 
 
1060
    @classmethod
 
1061
    def set_default_format(klass, format):
 
1062
        klass._default_format = format
 
1063
 
 
1064
    @classmethod
 
1065
    def unregister_format(klass, format):
 
1066
        del klass._formats[format.get_format_string()]
 
1067
 
 
1068
    def __str__(self):
 
1069
        return self.get_format_string().rstrip()
 
1070
 
 
1071
    def supports_tags(self):
 
1072
        """True if this format supports tags stored in the branch"""
 
1073
        return False  # by default
 
1074
 
 
1075
 
 
1076
class BranchHooks(Hooks):
 
1077
    """A dictionary mapping hook name to a list of callables for branch hooks.
 
1078
    
 
1079
    e.g. ['set_rh'] Is the list of items to be called when the
 
1080
    set_revision_history function is invoked.
 
1081
    """
 
1082
 
 
1083
    def __init__(self):
 
1084
        """Create the default hooks.
 
1085
 
 
1086
        These are all empty initially, because by default nothing should get
 
1087
        notified.
 
1088
        """
 
1089
        Hooks.__init__(self)
 
1090
        # Introduced in 0.15:
 
1091
        # invoked whenever the revision history has been set
 
1092
        # with set_revision_history. The api signature is
 
1093
        # (branch, revision_history), and the branch will
 
1094
        # be write-locked.
 
1095
        self['set_rh'] = []
 
1096
        # invoked after a push operation completes.
 
1097
        # the api signature is
 
1098
        # (push_result)
 
1099
        # containing the members
 
1100
        # (source, local, master, old_revno, old_revid, new_revno, new_revid)
 
1101
        # where local is the local target branch or None, master is the target 
 
1102
        # master branch, and the rest should be self explanatory. The source
 
1103
        # is read locked and the target branches write locked. Source will
 
1104
        # be the local low-latency branch.
 
1105
        self['post_push'] = []
 
1106
        # invoked after a pull operation completes.
 
1107
        # the api signature is
 
1108
        # (pull_result)
 
1109
        # containing the members
 
1110
        # (source, local, master, old_revno, old_revid, new_revno, new_revid)
 
1111
        # where local is the local branch or None, master is the target 
 
1112
        # master branch, and the rest should be self explanatory. The source
 
1113
        # is read locked and the target branches write locked. The local
 
1114
        # branch is the low-latency branch.
 
1115
        self['post_pull'] = []
 
1116
        # invoked before a commit operation takes place.
 
1117
        # the api signature is
 
1118
        # (local, master, old_revno, old_revid, future_revno, future_revid,
 
1119
        #  tree_delta, future_tree).
 
1120
        # old_revid is NULL_REVISION for the first commit to a branch
 
1121
        # tree_delta is a TreeDelta object describing changes from the basis
 
1122
        # revision, hooks MUST NOT modify this delta
 
1123
        # future_tree is an in-memory tree obtained from
 
1124
        # CommitBuilder.revision_tree() and hooks MUST NOT modify this tree
 
1125
        self['pre_commit'] = []
 
1126
        # invoked after a commit operation completes.
 
1127
        # the api signature is 
 
1128
        # (local, master, old_revno, old_revid, new_revno, new_revid)
 
1129
        # old_revid is NULL_REVISION for the first commit to a branch.
 
1130
        self['post_commit'] = []
 
1131
        # invoked after a uncommit operation completes.
 
1132
        # the api signature is
 
1133
        # (local, master, old_revno, old_revid, new_revno, new_revid) where
 
1134
        # local is the local branch or None, master is the target branch,
 
1135
        # and an empty branch recieves new_revno of 0, new_revid of None.
 
1136
        self['post_uncommit'] = []
 
1137
        # Introduced in 1.6
 
1138
        # Invoked before the tip of a branch changes.
 
1139
        # the api signature is
 
1140
        # (params) where params is a ChangeBranchTipParams with the members
 
1141
        # (branch, old_revno, new_revno, old_revid, new_revid)
 
1142
        self['pre_change_branch_tip'] = []
 
1143
        # Introduced in 1.4
 
1144
        # Invoked after the tip of a branch changes.
 
1145
        # the api signature is
 
1146
        # (params) where params is a ChangeBranchTipParams with the members
 
1147
        # (branch, old_revno, new_revno, old_revid, new_revid)
 
1148
        self['post_change_branch_tip'] = []
 
1149
 
 
1150
 
 
1151
# install the default hooks into the Branch class.
 
1152
Branch.hooks = BranchHooks()
 
1153
 
 
1154
 
 
1155
class ChangeBranchTipParams(object):
 
1156
    """Object holding parameters passed to *_change_branch_tip hooks.
 
1157
 
 
1158
    There are 5 fields that hooks may wish to access:
 
1159
 
 
1160
    :ivar branch: the branch being changed
 
1161
    :ivar old_revno: revision number before the change
 
1162
    :ivar new_revno: revision number after the change
 
1163
    :ivar old_revid: revision id before the change
 
1164
    :ivar new_revid: revision id after the change
 
1165
 
 
1166
    The revid fields are strings. The revno fields are integers.
 
1167
    """
 
1168
 
 
1169
    def __init__(self, branch, old_revno, new_revno, old_revid, new_revid):
 
1170
        """Create a group of ChangeBranchTip parameters.
 
1171
 
 
1172
        :param branch: The branch being changed.
 
1173
        :param old_revno: Revision number before the change.
 
1174
        :param new_revno: Revision number after the change.
 
1175
        :param old_revid: Tip revision id before the change.
 
1176
        :param new_revid: Tip revision id after the change.
 
1177
        """
 
1178
        self.branch = branch
 
1179
        self.old_revno = old_revno
 
1180
        self.new_revno = new_revno
 
1181
        self.old_revid = old_revid
 
1182
        self.new_revid = new_revid
 
1183
 
 
1184
    def __eq__(self, other):
 
1185
        return self.__dict__ == other.__dict__
 
1186
    
 
1187
    def __repr__(self):
 
1188
        return "<%s of %s from (%s, %s) to (%s, %s)>" % (
 
1189
            self.__class__.__name__, self.branch, 
 
1190
            self.old_revno, self.old_revid, self.new_revno, self.new_revid)
 
1191
 
 
1192
 
 
1193
class BzrBranchFormat4(BranchFormat):
 
1194
    """Bzr branch format 4.
 
1195
 
 
1196
    This format has:
 
1197
     - a revision-history file.
 
1198
     - a branch-lock lock file [ to be shared with the bzrdir ]
 
1199
    """
 
1200
 
 
1201
    def get_format_description(self):
 
1202
        """See BranchFormat.get_format_description()."""
 
1203
        return "Branch format 4"
 
1204
 
 
1205
    def initialize(self, a_bzrdir):
 
1206
        """Create a branch of this format in a_bzrdir."""
 
1207
        utf8_files = [('revision-history', ''),
 
1208
                      ('branch-name', ''),
 
1209
                      ]
 
1210
        return self._initialize_helper(a_bzrdir, utf8_files,
 
1211
                                       lock_type='branch4', set_format=False)
 
1212
 
 
1213
    def __init__(self):
 
1214
        super(BzrBranchFormat4, self).__init__()
 
1215
        self._matchingbzrdir = bzrdir.BzrDirFormat6()
 
1216
 
 
1217
    def open(self, a_bzrdir, _found=False):
 
1218
        """Return the branch object for a_bzrdir
 
1219
 
 
1220
        _found is a private parameter, do not use it. It is used to indicate
 
1221
               if format probing has already be done.
 
1222
        """
 
1223
        if not _found:
 
1224
            # we are being called directly and must probe.
 
1225
            raise NotImplementedError
 
1226
        return BzrBranch(_format=self,
 
1227
                         _control_files=a_bzrdir._control_files,
 
1228
                         a_bzrdir=a_bzrdir,
 
1229
                         _repository=a_bzrdir.open_repository())
 
1230
 
 
1231
    def __str__(self):
 
1232
        return "Bazaar-NG branch format 4"
 
1233
 
 
1234
 
 
1235
class BranchFormatMetadir(BranchFormat):
 
1236
    """Common logic for meta-dir based branch formats."""
 
1237
 
 
1238
    def _branch_class(self):
 
1239
        """What class to instantiate on open calls."""
 
1240
        raise NotImplementedError(self._branch_class)
 
1241
 
 
1242
    def open(self, a_bzrdir, _found=False):
 
1243
        """Return the branch object for a_bzrdir.
 
1244
 
 
1245
        _found is a private parameter, do not use it. It is used to indicate
 
1246
               if format probing has already be done.
 
1247
        """
 
1248
        if not _found:
 
1249
            format = BranchFormat.find_format(a_bzrdir)
 
1250
            if format.__class__ != self.__class__:
 
1251
                raise AssertionError("wrong format %r found for %r" %
 
1252
                    (format, self))
 
1253
        try:
 
1254
            transport = a_bzrdir.get_branch_transport(None)
 
1255
            control_files = lockable_files.LockableFiles(transport, 'lock',
 
1256
                                                         lockdir.LockDir)
 
1257
            return self._branch_class()(_format=self,
 
1258
                              _control_files=control_files,
 
1259
                              a_bzrdir=a_bzrdir,
 
1260
                              _repository=a_bzrdir.find_repository())
 
1261
        except errors.NoSuchFile:
 
1262
            raise errors.NotBranchError(path=transport.base)
 
1263
 
 
1264
    def __init__(self):
 
1265
        super(BranchFormatMetadir, self).__init__()
 
1266
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
 
1267
 
 
1268
    def supports_tags(self):
 
1269
        return True
 
1270
 
 
1271
 
 
1272
class BzrBranchFormat5(BranchFormatMetadir):
 
1273
    """Bzr branch format 5.
 
1274
 
 
1275
    This format has:
 
1276
     - a revision-history file.
 
1277
     - a format string
 
1278
     - a lock dir guarding the branch itself
 
1279
     - all of this stored in a branch/ subdirectory
 
1280
     - works with shared repositories.
 
1281
 
 
1282
    This format is new in bzr 0.8.
 
1283
    """
 
1284
 
 
1285
    def _branch_class(self):
 
1286
        return BzrBranch5
 
1287
 
 
1288
    def get_format_string(self):
 
1289
        """See BranchFormat.get_format_string()."""
 
1290
        return "Bazaar-NG branch format 5\n"
 
1291
 
 
1292
    def get_format_description(self):
 
1293
        """See BranchFormat.get_format_description()."""
 
1294
        return "Branch format 5"
 
1295
        
 
1296
    def initialize(self, a_bzrdir):
 
1297
        """Create a branch of this format in a_bzrdir."""
 
1298
        utf8_files = [('revision-history', ''),
 
1299
                      ('branch-name', ''),
 
1300
                      ]
 
1301
        return self._initialize_helper(a_bzrdir, utf8_files)
 
1302
 
 
1303
    def supports_tags(self):
 
1304
        return False
 
1305
 
 
1306
 
 
1307
class BzrBranchFormat6(BranchFormatMetadir):
 
1308
    """Branch format with last-revision and tags.
 
1309
 
 
1310
    Unlike previous formats, this has no explicit revision history. Instead,
 
1311
    this just stores the last-revision, and the left-hand history leading
 
1312
    up to there is the history.
 
1313
 
 
1314
    This format was introduced in bzr 0.15
 
1315
    and became the default in 0.91.
 
1316
    """
 
1317
 
 
1318
    def _branch_class(self):
 
1319
        return BzrBranch6
 
1320
 
 
1321
    def get_format_string(self):
 
1322
        """See BranchFormat.get_format_string()."""
 
1323
        return "Bazaar Branch Format 6 (bzr 0.15)\n"
 
1324
 
 
1325
    def get_format_description(self):
 
1326
        """See BranchFormat.get_format_description()."""
 
1327
        return "Branch format 6"
 
1328
 
 
1329
    def initialize(self, a_bzrdir):
 
1330
        """Create a branch of this format in a_bzrdir."""
 
1331
        utf8_files = [('last-revision', '0 null:\n'),
 
1332
                      ('branch.conf', ''),
 
1333
                      ('tags', ''),
 
1334
                      ]
 
1335
        return self._initialize_helper(a_bzrdir, utf8_files)
 
1336
 
 
1337
 
 
1338
class BzrBranchFormat7(BranchFormatMetadir):
 
1339
    """Branch format with last-revision, tags, and a stacked location pointer.
 
1340
 
 
1341
    The stacked location pointer is passed down to the repository and requires
 
1342
    a repository format with supports_external_lookups = True.
 
1343
 
 
1344
    This format was introduced in bzr 1.6.
 
1345
    """
 
1346
 
 
1347
    def _branch_class(self):
 
1348
        return BzrBranch7
 
1349
 
 
1350
    def get_format_string(self):
 
1351
        """See BranchFormat.get_format_string()."""
 
1352
        return "Bazaar Branch Format 7 (needs bzr 1.6)\n"
 
1353
 
 
1354
    def get_format_description(self):
 
1355
        """See BranchFormat.get_format_description()."""
 
1356
        return "Branch format 7"
 
1357
 
 
1358
    def initialize(self, a_bzrdir):
 
1359
        """Create a branch of this format in a_bzrdir."""
 
1360
        utf8_files = [('last-revision', '0 null:\n'),
 
1361
                      ('branch.conf', ''),
 
1362
                      ('tags', ''),
 
1363
                      ]
 
1364
        return self._initialize_helper(a_bzrdir, utf8_files)
 
1365
 
 
1366
    def __init__(self):
 
1367
        super(BzrBranchFormat7, self).__init__()
 
1368
        self._matchingbzrdir.repository_format = \
 
1369
            RepositoryFormatPackDevelopment1Subtree()
 
1370
 
 
1371
 
 
1372
class BranchReferenceFormat(BranchFormat):
 
1373
    """Bzr branch reference format.
 
1374
 
 
1375
    Branch references are used in implementing checkouts, they
 
1376
    act as an alias to the real branch which is at some other url.
 
1377
 
 
1378
    This format has:
 
1379
     - A location file
 
1380
     - a format string
 
1381
    """
 
1382
 
 
1383
    def get_format_string(self):
 
1384
        """See BranchFormat.get_format_string()."""
 
1385
        return "Bazaar-NG Branch Reference Format 1\n"
 
1386
 
 
1387
    def get_format_description(self):
 
1388
        """See BranchFormat.get_format_description()."""
 
1389
        return "Checkout reference format 1"
 
1390
 
 
1391
    def get_reference(self, a_bzrdir):
 
1392
        """See BranchFormat.get_reference()."""
 
1393
        transport = a_bzrdir.get_branch_transport(None)
 
1394
        return transport.get('location').read()
 
1395
 
 
1396
    def set_reference(self, a_bzrdir, to_branch):
 
1397
        """See BranchFormat.set_reference()."""
 
1398
        transport = a_bzrdir.get_branch_transport(None)
 
1399
        location = transport.put_bytes('location', to_branch.base)
 
1400
 
 
1401
    def initialize(self, a_bzrdir, target_branch=None):
 
1402
        """Create a branch of this format in a_bzrdir."""
 
1403
        if target_branch is None:
 
1404
            # this format does not implement branch itself, thus the implicit
 
1405
            # creation contract must see it as uninitializable
 
1406
            raise errors.UninitializableFormat(self)
 
1407
        mutter('creating branch reference in %s', a_bzrdir.transport.base)
 
1408
        branch_transport = a_bzrdir.get_branch_transport(self)
 
1409
        branch_transport.put_bytes('location',
 
1410
            target_branch.bzrdir.root_transport.base)
 
1411
        branch_transport.put_bytes('format', self.get_format_string())
 
1412
        return self.open(
 
1413
            a_bzrdir, _found=True,
 
1414
            possible_transports=[target_branch.bzrdir.root_transport])
 
1415
 
 
1416
    def __init__(self):
 
1417
        super(BranchReferenceFormat, self).__init__()
 
1418
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
 
1419
 
 
1420
    def _make_reference_clone_function(format, a_branch):
 
1421
        """Create a clone() routine for a branch dynamically."""
 
1422
        def clone(to_bzrdir, revision_id=None):
 
1423
            """See Branch.clone()."""
 
1424
            return format.initialize(to_bzrdir, a_branch)
 
1425
            # cannot obey revision_id limits when cloning a reference ...
 
1426
            # FIXME RBC 20060210 either nuke revision_id for clone, or
 
1427
            # emit some sort of warning/error to the caller ?!
 
1428
        return clone
 
1429
 
 
1430
    def open(self, a_bzrdir, _found=False, location=None,
 
1431
             possible_transports=None):
 
1432
        """Return the branch that the branch reference in a_bzrdir points at.
 
1433
 
 
1434
        _found is a private parameter, do not use it. It is used to indicate
 
1435
               if format probing has already be done.
 
1436
        """
 
1437
        if not _found:
 
1438
            format = BranchFormat.find_format(a_bzrdir)
 
1439
            if format.__class__ != self.__class__:
 
1440
                raise AssertionError("wrong format %r found for %r" %
 
1441
                    (format, self))
 
1442
        if location is None:
 
1443
            location = self.get_reference(a_bzrdir)
 
1444
        real_bzrdir = bzrdir.BzrDir.open(
 
1445
            location, possible_transports=possible_transports)
 
1446
        result = real_bzrdir.open_branch()
 
1447
        # this changes the behaviour of result.clone to create a new reference
 
1448
        # rather than a copy of the content of the branch.
 
1449
        # I did not use a proxy object because that needs much more extensive
 
1450
        # testing, and we are only changing one behaviour at the moment.
 
1451
        # If we decide to alter more behaviours - i.e. the implicit nickname
 
1452
        # then this should be refactored to introduce a tested proxy branch
 
1453
        # and a subclass of that for use in overriding clone() and ....
 
1454
        # - RBC 20060210
 
1455
        result.clone = self._make_reference_clone_function(result)
 
1456
        return result
 
1457
 
 
1458
 
 
1459
# formats which have no format string are not discoverable
 
1460
# and not independently creatable, so are not registered.
 
1461
__format5 = BzrBranchFormat5()
 
1462
__format6 = BzrBranchFormat6()
 
1463
__format7 = BzrBranchFormat7()
 
1464
BranchFormat.register_format(__format5)
 
1465
BranchFormat.register_format(BranchReferenceFormat())
 
1466
BranchFormat.register_format(__format6)
 
1467
BranchFormat.register_format(__format7)
 
1468
BranchFormat.set_default_format(__format6)
 
1469
_legacy_formats = [BzrBranchFormat4(),
 
1470
                   ]
 
1471
 
 
1472
class BzrBranch(Branch):
 
1473
    """A branch stored in the actual filesystem.
 
1474
 
 
1475
    Note that it's "local" in the context of the filesystem; it doesn't
 
1476
    really matter if it's on an nfs/smb/afs/coda/... share, as long as
 
1477
    it's writable, and can be accessed via the normal filesystem API.
 
1478
 
 
1479
    :ivar _transport: Transport for file operations on this branch's 
 
1480
        control files, typically pointing to the .bzr/branch directory.
 
1481
    :ivar repository: Repository for this branch.
 
1482
    :ivar base: The url of the base directory for this branch; the one 
 
1483
        containing the .bzr directory.
 
1484
    """
 
1485
    
 
1486
    def __init__(self, _format=None,
 
1487
                 _control_files=None, a_bzrdir=None, _repository=None):
 
1488
        """Create new branch object at a particular location."""
 
1489
        if a_bzrdir is None:
 
1490
            raise ValueError('a_bzrdir must be supplied')
 
1491
        else:
 
1492
            self.bzrdir = a_bzrdir
 
1493
        self._base = self.bzrdir.transport.clone('..').base
 
1494
        # XXX: We should be able to just do
 
1495
        #   self.base = self.bzrdir.root_transport.base
 
1496
        # but this does not quite work yet -- mbp 20080522
 
1497
        self._format = _format
 
1498
        if _control_files is None:
 
1499
            raise ValueError('BzrBranch _control_files is None')
 
1500
        self.control_files = _control_files
 
1501
        self._transport = _control_files._transport
 
1502
        self.repository = _repository
 
1503
        Branch.__init__(self)
 
1504
 
 
1505
    def __str__(self):
 
1506
        return '%s(%r)' % (self.__class__.__name__, self.base)
 
1507
 
 
1508
    __repr__ = __str__
 
1509
 
 
1510
    def _get_base(self):
 
1511
        """Returns the directory containing the control directory."""
 
1512
        return self._base
 
1513
 
 
1514
    base = property(_get_base, doc="The URL for the root of this branch.")
 
1515
 
 
1516
    @deprecated_method(deprecated_in((0, 16, 0)))
 
1517
    def abspath(self, name):
 
1518
        """See Branch.abspath."""
 
1519
        return self._transport.abspath(name)
 
1520
 
 
1521
    def is_locked(self):
 
1522
        return self.control_files.is_locked()
 
1523
 
 
1524
    def lock_write(self, token=None):
 
1525
        repo_token = self.repository.lock_write()
 
1526
        try:
 
1527
            token = self.control_files.lock_write(token=token)
 
1528
        except:
 
1529
            self.repository.unlock()
 
1530
            raise
 
1531
        return token
 
1532
 
 
1533
    def lock_read(self):
 
1534
        self.repository.lock_read()
 
1535
        try:
 
1536
            self.control_files.lock_read()
 
1537
        except:
 
1538
            self.repository.unlock()
 
1539
            raise
 
1540
 
 
1541
    def unlock(self):
 
1542
        # TODO: test for failed two phase locks. This is known broken.
 
1543
        try:
 
1544
            self.control_files.unlock()
 
1545
        finally:
 
1546
            self.repository.unlock()
 
1547
        if not self.control_files.is_locked():
 
1548
            # we just released the lock
 
1549
            self._clear_cached_state()
 
1550
        
 
1551
    def peek_lock_mode(self):
 
1552
        if self.control_files._lock_count == 0:
 
1553
            return None
 
1554
        else:
 
1555
            return self.control_files._lock_mode
 
1556
 
 
1557
    def get_physical_lock_status(self):
 
1558
        return self.control_files.get_physical_lock_status()
 
1559
 
 
1560
    @needs_read_lock
 
1561
    def print_file(self, file, revision_id):
 
1562
        """See Branch.print_file."""
 
1563
        return self.repository.print_file(file, revision_id)
 
1564
 
 
1565
    def _write_revision_history(self, history):
 
1566
        """Factored out of set_revision_history.
 
1567
 
 
1568
        This performs the actual writing to disk.
 
1569
        It is intended to be called by BzrBranch5.set_revision_history."""
 
1570
        self._transport.put_bytes(
 
1571
            'revision-history', '\n'.join(history),
 
1572
            mode=self.bzrdir._get_file_mode())
 
1573
 
 
1574
    @needs_write_lock
 
1575
    def set_revision_history(self, rev_history):
 
1576
        """See Branch.set_revision_history."""
 
1577
        if 'evil' in debug.debug_flags:
 
1578
            mutter_callsite(3, "set_revision_history scales with history.")
 
1579
        check_not_reserved_id = _mod_revision.check_not_reserved_id
 
1580
        for rev_id in rev_history:
 
1581
            check_not_reserved_id(rev_id)
 
1582
        old_revno, old_revid = self.last_revision_info()
 
1583
        if len(rev_history) == 0:
 
1584
            revid = _mod_revision.NULL_REVISION
 
1585
        else:
 
1586
            revid = rev_history[-1]
 
1587
        self._run_pre_change_branch_tip_hooks(len(rev_history), revid)
 
1588
        self._write_revision_history(rev_history)
 
1589
        self._clear_cached_state()
 
1590
        self._cache_revision_history(rev_history)
 
1591
        for hook in Branch.hooks['set_rh']:
 
1592
            hook(self, rev_history)
 
1593
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
 
1594
 
 
1595
    def _run_pre_change_branch_tip_hooks(self, new_revno, new_revid):
 
1596
        """Run the pre_change_branch_tip hooks."""
 
1597
        hooks = Branch.hooks['pre_change_branch_tip']
 
1598
        if not hooks:
 
1599
            return
 
1600
        old_revno, old_revid = self.last_revision_info()
 
1601
        params = ChangeBranchTipParams(
 
1602
            self, old_revno, new_revno, old_revid, new_revid)
 
1603
        for hook in hooks:
 
1604
            try:
 
1605
                hook(params)
 
1606
            except errors.TipChangeRejected:
 
1607
                raise
 
1608
            except Exception:
 
1609
                exc_info = sys.exc_info()
 
1610
                hook_name = Branch.hooks.get_hook_name(hook)
 
1611
                raise errors.HookFailed(
 
1612
                    'pre_change_branch_tip', hook_name, exc_info)
 
1613
 
 
1614
    def _run_post_change_branch_tip_hooks(self, old_revno, old_revid):
 
1615
        """Run the post_change_branch_tip hooks."""
 
1616
        hooks = Branch.hooks['post_change_branch_tip']
 
1617
        if not hooks:
 
1618
            return
 
1619
        new_revno, new_revid = self.last_revision_info()
 
1620
        params = ChangeBranchTipParams(
 
1621
            self, old_revno, new_revno, old_revid, new_revid)
 
1622
        for hook in hooks:
 
1623
            hook(params)
 
1624
 
 
1625
    @needs_write_lock
 
1626
    def set_last_revision_info(self, revno, revision_id):
 
1627
        """Set the last revision of this branch.
 
1628
 
 
1629
        The caller is responsible for checking that the revno is correct
 
1630
        for this revision id.
 
1631
 
 
1632
        It may be possible to set the branch last revision to an id not
 
1633
        present in the repository.  However, branches can also be 
 
1634
        configured to check constraints on history, in which case this may not
 
1635
        be permitted.
 
1636
        """
 
1637
        revision_id = _mod_revision.ensure_null(revision_id)
 
1638
        # this old format stores the full history, but this api doesn't
 
1639
        # provide it, so we must generate, and might as well check it's
 
1640
        # correct
 
1641
        history = self._lefthand_history(revision_id)
 
1642
        if len(history) != revno:
 
1643
            raise AssertionError('%d != %d' % (len(history), revno))
 
1644
        self.set_revision_history(history)
 
1645
 
 
1646
    def _gen_revision_history(self):
 
1647
        history = self._transport.get_bytes('revision-history').split('\n')
 
1648
        if history[-1:] == ['']:
 
1649
            # There shouldn't be a trailing newline, but just in case.
 
1650
            history.pop()
 
1651
        return history
 
1652
 
 
1653
    def _lefthand_history(self, revision_id, last_rev=None,
 
1654
                          other_branch=None):
 
1655
        if 'evil' in debug.debug_flags:
 
1656
            mutter_callsite(4, "_lefthand_history scales with history.")
 
1657
        # stop_revision must be a descendant of last_revision
 
1658
        graph = self.repository.get_graph()
 
1659
        if last_rev is not None:
 
1660
            if not graph.is_ancestor(last_rev, revision_id):
 
1661
                # our previous tip is not merged into stop_revision
 
1662
                raise errors.DivergedBranches(self, other_branch)
 
1663
        # make a new revision history from the graph
 
1664
        parents_map = graph.get_parent_map([revision_id])
 
1665
        if revision_id not in parents_map:
 
1666
            raise errors.NoSuchRevision(self, revision_id)
 
1667
        current_rev_id = revision_id
 
1668
        new_history = []
 
1669
        check_not_reserved_id = _mod_revision.check_not_reserved_id
 
1670
        # Do not include ghosts or graph origin in revision_history
 
1671
        while (current_rev_id in parents_map and
 
1672
               len(parents_map[current_rev_id]) > 0):
 
1673
            check_not_reserved_id(current_rev_id)
 
1674
            new_history.append(current_rev_id)
 
1675
            current_rev_id = parents_map[current_rev_id][0]
 
1676
            parents_map = graph.get_parent_map([current_rev_id])
 
1677
        new_history.reverse()
 
1678
        return new_history
 
1679
 
 
1680
    @needs_write_lock
 
1681
    def generate_revision_history(self, revision_id, last_rev=None,
 
1682
        other_branch=None):
 
1683
        """Create a new revision history that will finish with revision_id.
 
1684
 
 
1685
        :param revision_id: the new tip to use.
 
1686
        :param last_rev: The previous last_revision. If not None, then this
 
1687
            must be a ancestory of revision_id, or DivergedBranches is raised.
 
1688
        :param other_branch: The other branch that DivergedBranches should
 
1689
            raise with respect to.
 
1690
        """
 
1691
        self.set_revision_history(self._lefthand_history(revision_id,
 
1692
            last_rev, other_branch))
 
1693
 
 
1694
    def basis_tree(self):
 
1695
        """See Branch.basis_tree."""
 
1696
        return self.repository.revision_tree(self.last_revision())
 
1697
 
 
1698
    @needs_write_lock
 
1699
    def pull(self, source, overwrite=False, stop_revision=None,
 
1700
             _hook_master=None, run_hooks=True, possible_transports=None,
 
1701
             _override_hook_target=None):
 
1702
        """See Branch.pull.
 
1703
 
 
1704
        :param _hook_master: Private parameter - set the branch to 
 
1705
            be supplied as the master to pull hooks.
 
1706
        :param run_hooks: Private parameter - if false, this branch
 
1707
            is being called because it's the master of the primary branch,
 
1708
            so it should not run its hooks.
 
1709
        :param _override_hook_target: Private parameter - set the branch to be
 
1710
            supplied as the target_branch to pull hooks.
 
1711
        """
 
1712
        result = PullResult()
 
1713
        result.source_branch = source
 
1714
        if _override_hook_target is None:
 
1715
            result.target_branch = self
 
1716
        else:
 
1717
            result.target_branch = _override_hook_target
 
1718
        source.lock_read()
 
1719
        try:
 
1720
            # We assume that during 'pull' the local repository is closer than
 
1721
            # the remote one.
 
1722
            graph = self.repository.get_graph(source.repository)
 
1723
            result.old_revno, result.old_revid = self.last_revision_info()
 
1724
            self.update_revisions(source, stop_revision, overwrite=overwrite,
 
1725
                                  graph=graph)
 
1726
            result.tag_conflicts = source.tags.merge_to(self.tags, overwrite)
 
1727
            result.new_revno, result.new_revid = self.last_revision_info()
 
1728
            if _hook_master:
 
1729
                result.master_branch = _hook_master
 
1730
                result.local_branch = result.target_branch
 
1731
            else:
 
1732
                result.master_branch = result.target_branch
 
1733
                result.local_branch = None
 
1734
            if run_hooks:
 
1735
                for hook in Branch.hooks['post_pull']:
 
1736
                    hook(result)
 
1737
        finally:
 
1738
            source.unlock()
 
1739
        return result
 
1740
 
 
1741
    def _get_parent_location(self):
 
1742
        _locs = ['parent', 'pull', 'x-pull']
 
1743
        for l in _locs:
 
1744
            try:
 
1745
                return self._transport.get_bytes(l).strip('\n')
 
1746
            except errors.NoSuchFile:
 
1747
                pass
 
1748
        return None
 
1749
 
 
1750
    @needs_read_lock
 
1751
    def push(self, target, overwrite=False, stop_revision=None,
 
1752
             _override_hook_source_branch=None):
 
1753
        """See Branch.push.
 
1754
 
 
1755
        This is the basic concrete implementation of push()
 
1756
 
 
1757
        :param _override_hook_source_branch: If specified, run
 
1758
        the hooks passing this Branch as the source, rather than self.  
 
1759
        This is for use of RemoteBranch, where push is delegated to the
 
1760
        underlying vfs-based Branch. 
 
1761
        """
 
1762
        # TODO: Public option to disable running hooks - should be trivial but
 
1763
        # needs tests.
 
1764
        target.lock_write()
 
1765
        try:
 
1766
            result = self._push_with_bound_branches(target, overwrite,
 
1767
                    stop_revision,
 
1768
                    _override_hook_source_branch=_override_hook_source_branch)
 
1769
            return result
 
1770
        finally:
 
1771
            target.unlock()
 
1772
 
 
1773
    def _push_with_bound_branches(self, target, overwrite,
 
1774
            stop_revision,
 
1775
            _override_hook_source_branch=None):
 
1776
        """Push from self into target, and into target's master if any.
 
1777
        
 
1778
        This is on the base BzrBranch class even though it doesn't support 
 
1779
        bound branches because the *target* might be bound.
 
1780
        """
 
1781
        def _run_hooks():
 
1782
            if _override_hook_source_branch:
 
1783
                result.source_branch = _override_hook_source_branch
 
1784
            for hook in Branch.hooks['post_push']:
 
1785
                hook(result)
 
1786
 
 
1787
        bound_location = target.get_bound_location()
 
1788
        if bound_location and target.base != bound_location:
 
1789
            # there is a master branch.
 
1790
            #
 
1791
            # XXX: Why the second check?  Is it even supported for a branch to
 
1792
            # be bound to itself? -- mbp 20070507
 
1793
            master_branch = target.get_master_branch()
 
1794
            master_branch.lock_write()
 
1795
            try:
 
1796
                # push into the master from this branch.
 
1797
                self._basic_push(master_branch, overwrite, stop_revision)
 
1798
                # and push into the target branch from this. Note that we push from
 
1799
                # this branch again, because its considered the highest bandwidth
 
1800
                # repository.
 
1801
                result = self._basic_push(target, overwrite, stop_revision)
 
1802
                result.master_branch = master_branch
 
1803
                result.local_branch = target
 
1804
                _run_hooks()
 
1805
                return result
 
1806
            finally:
 
1807
                master_branch.unlock()
 
1808
        else:
 
1809
            # no master branch
 
1810
            result = self._basic_push(target, overwrite, stop_revision)
 
1811
            # TODO: Why set master_branch and local_branch if there's no
 
1812
            # binding?  Maybe cleaner to just leave them unset? -- mbp
 
1813
            # 20070504
 
1814
            result.master_branch = target
 
1815
            result.local_branch = None
 
1816
            _run_hooks()
 
1817
            return result
 
1818
 
 
1819
    def _basic_push(self, target, overwrite, stop_revision):
 
1820
        """Basic implementation of push without bound branches or hooks.
 
1821
 
 
1822
        Must be called with self read locked and target write locked.
 
1823
        """
 
1824
        result = PushResult()
 
1825
        result.source_branch = self
 
1826
        result.target_branch = target
 
1827
        result.old_revno, result.old_revid = target.last_revision_info()
 
1828
 
 
1829
        # We assume that during 'push' this repository is closer than
 
1830
        # the target.
 
1831
        graph = self.repository.get_graph(target.repository)
 
1832
        target.update_revisions(self, stop_revision, overwrite=overwrite,
 
1833
                                graph=graph)
 
1834
        result.tag_conflicts = self.tags.merge_to(target.tags, overwrite)
 
1835
        result.new_revno, result.new_revid = target.last_revision_info()
 
1836
        return result
 
1837
 
 
1838
    def get_parent(self):
 
1839
        """See Branch.get_parent."""
 
1840
        parent = self._get_parent_location()
 
1841
        if parent is None:
 
1842
            return parent
 
1843
        # This is an old-format absolute path to a local branch
 
1844
        # turn it into a url
 
1845
        if parent.startswith('/'):
 
1846
            parent = urlutils.local_path_to_url(parent.decode('utf8'))
 
1847
        try:
 
1848
            return urlutils.join(self.base[:-1], parent)
 
1849
        except errors.InvalidURLJoin, e:
 
1850
            raise errors.InaccessibleParent(parent, self.base)
 
1851
 
 
1852
    def get_stacked_on_url(self):
 
1853
        raise errors.UnstackableBranchFormat(self._format, self.base)
 
1854
 
 
1855
    def set_push_location(self, location):
 
1856
        """See Branch.set_push_location."""
 
1857
        self.get_config().set_user_option(
 
1858
            'push_location', location,
 
1859
            store=_mod_config.STORE_LOCATION_NORECURSE)
 
1860
 
 
1861
    @needs_write_lock
 
1862
    def set_parent(self, url):
 
1863
        """See Branch.set_parent."""
 
1864
        # TODO: Maybe delete old location files?
 
1865
        # URLs should never be unicode, even on the local fs,
 
1866
        # FIXUP this and get_parent in a future branch format bump:
 
1867
        # read and rewrite the file. RBC 20060125
 
1868
        if url is not None:
 
1869
            if isinstance(url, unicode):
 
1870
                try:
 
1871
                    url = url.encode('ascii')
 
1872
                except UnicodeEncodeError:
 
1873
                    raise errors.InvalidURL(url,
 
1874
                        "Urls must be 7-bit ascii, "
 
1875
                        "use bzrlib.urlutils.escape")
 
1876
            url = urlutils.relative_url(self.base, url)
 
1877
        self._set_parent_location(url)
 
1878
 
 
1879
    def _set_parent_location(self, url):
 
1880
        if url is None:
 
1881
            self._transport.delete('parent')
 
1882
        else:
 
1883
            self._transport.put_bytes('parent', url + '\n',
 
1884
                mode=self.bzrdir._get_file_mode())
 
1885
 
 
1886
    def set_stacked_on_url(self, url):
 
1887
        raise errors.UnstackableBranchFormat(self._format, self.base)
 
1888
 
 
1889
 
 
1890
class BzrBranch5(BzrBranch):
 
1891
    """A format 5 branch. This supports new features over plain branches.
 
1892
 
 
1893
    It has support for a master_branch which is the data for bound branches.
 
1894
    """
 
1895
 
 
1896
    @needs_write_lock
 
1897
    def pull(self, source, overwrite=False, stop_revision=None,
 
1898
             run_hooks=True, possible_transports=None,
 
1899
             _override_hook_target=None):
 
1900
        """Pull from source into self, updating my master if any.
 
1901
        
 
1902
        :param run_hooks: Private parameter - if false, this branch
 
1903
            is being called because it's the master of the primary branch,
 
1904
            so it should not run its hooks.
 
1905
        """
 
1906
        bound_location = self.get_bound_location()
 
1907
        master_branch = None
 
1908
        if bound_location and source.base != bound_location:
 
1909
            # not pulling from master, so we need to update master.
 
1910
            master_branch = self.get_master_branch(possible_transports)
 
1911
            master_branch.lock_write()
 
1912
        try:
 
1913
            if master_branch:
 
1914
                # pull from source into master.
 
1915
                master_branch.pull(source, overwrite, stop_revision,
 
1916
                    run_hooks=False)
 
1917
            return super(BzrBranch5, self).pull(source, overwrite,
 
1918
                stop_revision, _hook_master=master_branch,
 
1919
                run_hooks=run_hooks,
 
1920
                _override_hook_target=_override_hook_target)
 
1921
        finally:
 
1922
            if master_branch:
 
1923
                master_branch.unlock()
 
1924
 
 
1925
    def get_bound_location(self):
 
1926
        try:
 
1927
            return self._transport.get_bytes('bound')[:-1]
 
1928
        except errors.NoSuchFile:
 
1929
            return None
 
1930
 
 
1931
    @needs_read_lock
 
1932
    def get_master_branch(self, possible_transports=None):
 
1933
        """Return the branch we are bound to.
 
1934
        
 
1935
        :return: Either a Branch, or None
 
1936
 
 
1937
        This could memoise the branch, but if thats done
 
1938
        it must be revalidated on each new lock.
 
1939
        So for now we just don't memoise it.
 
1940
        # RBC 20060304 review this decision.
 
1941
        """
 
1942
        bound_loc = self.get_bound_location()
 
1943
        if not bound_loc:
 
1944
            return None
 
1945
        try:
 
1946
            return Branch.open(bound_loc,
 
1947
                               possible_transports=possible_transports)
 
1948
        except (errors.NotBranchError, errors.ConnectionError), e:
 
1949
            raise errors.BoundBranchConnectionFailure(
 
1950
                    self, bound_loc, e)
 
1951
 
 
1952
    @needs_write_lock
 
1953
    def set_bound_location(self, location):
 
1954
        """Set the target where this branch is bound to.
 
1955
 
 
1956
        :param location: URL to the target branch
 
1957
        """
 
1958
        if location:
 
1959
            self._transport.put_bytes('bound', location+'\n',
 
1960
                mode=self.bzrdir._get_file_mode())
 
1961
        else:
 
1962
            try:
 
1963
                self._transport.delete('bound')
 
1964
            except errors.NoSuchFile:
 
1965
                return False
 
1966
            return True
 
1967
 
 
1968
    @needs_write_lock
 
1969
    def bind(self, other):
 
1970
        """Bind this branch to the branch other.
 
1971
 
 
1972
        This does not push or pull data between the branches, though it does
 
1973
        check for divergence to raise an error when the branches are not
 
1974
        either the same, or one a prefix of the other. That behaviour may not
 
1975
        be useful, so that check may be removed in future.
 
1976
        
 
1977
        :param other: The branch to bind to
 
1978
        :type other: Branch
 
1979
        """
 
1980
        # TODO: jam 20051230 Consider checking if the target is bound
 
1981
        #       It is debatable whether you should be able to bind to
 
1982
        #       a branch which is itself bound.
 
1983
        #       Committing is obviously forbidden,
 
1984
        #       but binding itself may not be.
 
1985
        #       Since we *have* to check at commit time, we don't
 
1986
        #       *need* to check here
 
1987
 
 
1988
        # we want to raise diverged if:
 
1989
        # last_rev is not in the other_last_rev history, AND
 
1990
        # other_last_rev is not in our history, and do it without pulling
 
1991
        # history around
 
1992
        self.set_bound_location(other.base)
 
1993
 
 
1994
    @needs_write_lock
 
1995
    def unbind(self):
 
1996
        """If bound, unbind"""
 
1997
        return self.set_bound_location(None)
 
1998
 
 
1999
    @needs_write_lock
 
2000
    def update(self, possible_transports=None):
 
2001
        """Synchronise this branch with the master branch if any. 
 
2002
 
 
2003
        :return: None or the last_revision that was pivoted out during the
 
2004
                 update.
 
2005
        """
 
2006
        master = self.get_master_branch(possible_transports)
 
2007
        if master is not None:
 
2008
            old_tip = _mod_revision.ensure_null(self.last_revision())
 
2009
            self.pull(master, overwrite=True)
 
2010
            if self.repository.get_graph().is_ancestor(old_tip,
 
2011
                _mod_revision.ensure_null(self.last_revision())):
 
2012
                return None
 
2013
            return old_tip
 
2014
        return None
 
2015
 
 
2016
 
 
2017
class BzrBranch7(BzrBranch5):
 
2018
    """A branch with support for a fallback repository."""
 
2019
 
 
2020
    def _get_fallback_repository(self, url):
 
2021
        """Get the repository we fallback to at url."""
 
2022
        url = urlutils.join(self.base, url)
 
2023
        return bzrdir.BzrDir.open(url).open_branch().repository
 
2024
 
 
2025
    def _activate_fallback_location(self, url):
 
2026
        """Activate the branch/repository from url as a fallback repository."""
 
2027
        self.repository.add_fallback_repository(
 
2028
            self._get_fallback_repository(url))
 
2029
 
 
2030
    def _open_hook(self):
 
2031
        try:
 
2032
            url = self.get_stacked_on_url()
 
2033
        except (errors.UnstackableRepositoryFormat, errors.NotStacked,
 
2034
            errors.UnstackableBranchFormat):
 
2035
            pass
 
2036
        else:
 
2037
            self._activate_fallback_location(url)
 
2038
 
 
2039
    def _check_stackable_repo(self):
 
2040
        if not self.repository._format.supports_external_lookups:
 
2041
            raise errors.UnstackableRepositoryFormat(self.repository._format,
 
2042
                self.repository.base)
 
2043
 
 
2044
    def __init__(self, *args, **kwargs):
 
2045
        super(BzrBranch7, self).__init__(*args, **kwargs)
 
2046
        self._last_revision_info_cache = None
 
2047
        self._partial_revision_history_cache = []
 
2048
 
 
2049
    def _clear_cached_state(self):
 
2050
        super(BzrBranch7, self)._clear_cached_state()
 
2051
        self._last_revision_info_cache = None
 
2052
        self._partial_revision_history_cache = []
 
2053
 
 
2054
    def _last_revision_info(self):
 
2055
        revision_string = self._transport.get_bytes('last-revision')
 
2056
        revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
 
2057
        revision_id = cache_utf8.get_cached_utf8(revision_id)
 
2058
        revno = int(revno)
 
2059
        return revno, revision_id
 
2060
 
 
2061
    def _write_last_revision_info(self, revno, revision_id):
 
2062
        """Simply write out the revision id, with no checks.
 
2063
 
 
2064
        Use set_last_revision_info to perform this safely.
 
2065
 
 
2066
        Does not update the revision_history cache.
 
2067
        Intended to be called by set_last_revision_info and
 
2068
        _write_revision_history.
 
2069
        """
 
2070
        revision_id = _mod_revision.ensure_null(revision_id)
 
2071
        out_string = '%d %s\n' % (revno, revision_id)
 
2072
        self._transport.put_bytes('last-revision', out_string,
 
2073
            mode=self.bzrdir._get_file_mode())
 
2074
 
 
2075
    @needs_write_lock
 
2076
    def set_last_revision_info(self, revno, revision_id):
 
2077
        revision_id = _mod_revision.ensure_null(revision_id)
 
2078
        old_revno, old_revid = self.last_revision_info()
 
2079
        if self._get_append_revisions_only():
 
2080
            self._check_history_violation(revision_id)
 
2081
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
 
2082
        self._write_last_revision_info(revno, revision_id)
 
2083
        self._clear_cached_state()
 
2084
        self._last_revision_info_cache = revno, revision_id
 
2085
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
 
2086
 
 
2087
    def _check_history_violation(self, revision_id):
 
2088
        last_revision = _mod_revision.ensure_null(self.last_revision())
 
2089
        if _mod_revision.is_null(last_revision):
 
2090
            return
 
2091
        if last_revision not in self._lefthand_history(revision_id):
 
2092
            raise errors.AppendRevisionsOnlyViolation(self.base)
 
2093
 
 
2094
    def _gen_revision_history(self):
 
2095
        """Generate the revision history from last revision
 
2096
        """
 
2097
        last_revno, last_revision = self.last_revision_info()
 
2098
        self._extend_partial_history(stop_index=last_revno-1)
 
2099
        return list(reversed(self._partial_revision_history_cache))
 
2100
 
 
2101
    def _extend_partial_history(self, stop_index=None, stop_revision=None):
 
2102
        """Extend the partial history to include a given index
 
2103
 
 
2104
        If a stop_index is supplied, stop when that index has been reached.
 
2105
        If a stop_revision is supplied, stop when that revision is
 
2106
        encountered.  Otherwise, stop when the beginning of history is
 
2107
        reached.
 
2108
 
 
2109
        :param stop_index: The index which should be present.  When it is
 
2110
            present, history extension will stop.
 
2111
        :param revision_id: The revision id which should be present.  When
 
2112
            it is encountered, history extension will stop.
 
2113
        """
 
2114
        repo = self.repository
 
2115
        if len(self._partial_revision_history_cache) == 0:
 
2116
            iterator = repo.iter_reverse_revision_history(self.last_revision())
 
2117
        else:
 
2118
            start_revision = self._partial_revision_history_cache[-1]
 
2119
            iterator = repo.iter_reverse_revision_history(start_revision)
 
2120
            #skip the last revision in the list
 
2121
            next_revision = iterator.next()
 
2122
        for revision_id in iterator:
 
2123
            self._partial_revision_history_cache.append(revision_id)
 
2124
            if (stop_index is not None and
 
2125
                len(self._partial_revision_history_cache) > stop_index):
 
2126
                break
 
2127
            if revision_id == stop_revision:
 
2128
                break
 
2129
 
 
2130
    def _write_revision_history(self, history):
 
2131
        """Factored out of set_revision_history.
 
2132
 
 
2133
        This performs the actual writing to disk, with format-specific checks.
 
2134
        It is intended to be called by BzrBranch5.set_revision_history.
 
2135
        """
 
2136
        if len(history) == 0:
 
2137
            last_revision = 'null:'
 
2138
        else:
 
2139
            if history != self._lefthand_history(history[-1]):
 
2140
                raise errors.NotLefthandHistory(history)
 
2141
            last_revision = history[-1]
 
2142
        if self._get_append_revisions_only():
 
2143
            self._check_history_violation(last_revision)
 
2144
        self._write_last_revision_info(len(history), last_revision)
 
2145
 
 
2146
    @needs_write_lock
 
2147
    def _set_parent_location(self, url):
 
2148
        """Set the parent branch"""
 
2149
        self._set_config_location('parent_location', url, make_relative=True)
 
2150
 
 
2151
    @needs_read_lock
 
2152
    def _get_parent_location(self):
 
2153
        """Set the parent branch"""
 
2154
        return self._get_config_location('parent_location')
 
2155
 
 
2156
    def set_push_location(self, location):
 
2157
        """See Branch.set_push_location."""
 
2158
        self._set_config_location('push_location', location)
 
2159
 
 
2160
    def set_bound_location(self, location):
 
2161
        """See Branch.set_push_location."""
 
2162
        result = None
 
2163
        config = self.get_config()
 
2164
        if location is None:
 
2165
            if config.get_user_option('bound') != 'True':
 
2166
                return False
 
2167
            else:
 
2168
                config.set_user_option('bound', 'False', warn_masked=True)
 
2169
                return True
 
2170
        else:
 
2171
            self._set_config_location('bound_location', location,
 
2172
                                      config=config)
 
2173
            config.set_user_option('bound', 'True', warn_masked=True)
 
2174
        return True
 
2175
 
 
2176
    def _get_bound_location(self, bound):
 
2177
        """Return the bound location in the config file.
 
2178
 
 
2179
        Return None if the bound parameter does not match"""
 
2180
        config = self.get_config()
 
2181
        config_bound = (config.get_user_option('bound') == 'True')
 
2182
        if config_bound != bound:
 
2183
            return None
 
2184
        return self._get_config_location('bound_location', config=config)
 
2185
 
 
2186
    def get_bound_location(self):
 
2187
        """See Branch.set_push_location."""
 
2188
        return self._get_bound_location(True)
 
2189
 
 
2190
    def get_old_bound_location(self):
 
2191
        """See Branch.get_old_bound_location"""
 
2192
        return self._get_bound_location(False)
 
2193
 
 
2194
    def get_stacked_on_url(self):
 
2195
        self._check_stackable_repo()
 
2196
        stacked_url = self._get_config_location('stacked_on_location')
 
2197
        if stacked_url is None:
 
2198
            raise errors.NotStacked(self)
 
2199
        return stacked_url
 
2200
 
 
2201
    def set_append_revisions_only(self, enabled):
 
2202
        if enabled:
 
2203
            value = 'True'
 
2204
        else:
 
2205
            value = 'False'
 
2206
        self.get_config().set_user_option('append_revisions_only', value,
 
2207
            warn_masked=True)
 
2208
 
 
2209
    def set_stacked_on_url(self, url):
 
2210
        self._check_stackable_repo()
 
2211
        if not url:
 
2212
            try:
 
2213
                old_url = self.get_stacked_on_url()
 
2214
            except (errors.NotStacked, errors.UnstackableBranchFormat,
 
2215
                errors.UnstackableRepositoryFormat):
 
2216
                return
 
2217
            url = ''
 
2218
            # repositories don't offer an interface to remove fallback
 
2219
            # repositories today; take the conceptually simpler option and just
 
2220
            # reopen it.
 
2221
            self.repository = self.bzrdir.find_repository()
 
2222
            # for every revision reference the branch has, ensure it is pulled
 
2223
            # in.
 
2224
            source_repository = self._get_fallback_repository(old_url)
 
2225
            for revision_id in chain([self.last_revision()],
 
2226
                self.tags.get_reverse_tag_dict()):
 
2227
                self.repository.fetch(source_repository, revision_id,
 
2228
                    find_ghosts=True)
 
2229
        else:
 
2230
            self._activate_fallback_location(url)
 
2231
        # write this out after the repository is stacked to avoid setting a
 
2232
        # stacked config that doesn't work.
 
2233
        self._set_config_location('stacked_on_location', url)
 
2234
 
 
2235
    def _get_append_revisions_only(self):
 
2236
        value = self.get_config().get_user_option('append_revisions_only')
 
2237
        return value == 'True'
 
2238
 
 
2239
    def _synchronize_history(self, destination, revision_id):
 
2240
        """Synchronize last revision and revision history between branches.
 
2241
 
 
2242
        This version is most efficient when the destination is also a
 
2243
        BzrBranch6, but works for BzrBranch5, as long as the destination's
 
2244
        repository contains all the lefthand ancestors of the intended
 
2245
        last_revision.  If not, set_last_revision_info will fail.
 
2246
 
 
2247
        :param destination: The branch to copy the history into
 
2248
        :param revision_id: The revision-id to truncate history at.  May
 
2249
          be None to copy complete history.
 
2250
        """
 
2251
        source_revno, source_revision_id = self.last_revision_info()
 
2252
        if revision_id is None:
 
2253
            revno, revision_id = source_revno, source_revision_id
 
2254
        elif source_revision_id == revision_id:
 
2255
            # we know the revno without needing to walk all of history
 
2256
            revno = source_revno
 
2257
        else:
 
2258
            # To figure out the revno for a random revision, we need to build
 
2259
            # the revision history, and count its length.
 
2260
            # We don't care about the order, just how long it is.
 
2261
            # Alternatively, we could start at the current location, and count
 
2262
            # backwards. But there is no guarantee that we will find it since
 
2263
            # it may be a merged revision.
 
2264
            revno = len(list(self.repository.iter_reverse_revision_history(
 
2265
                                                                revision_id)))
 
2266
        destination.set_last_revision_info(revno, revision_id)
 
2267
 
 
2268
    def _make_tags(self):
 
2269
        return BasicTags(self)
 
2270
 
 
2271
    @needs_write_lock
 
2272
    def generate_revision_history(self, revision_id, last_rev=None,
 
2273
                                  other_branch=None):
 
2274
        """See BzrBranch5.generate_revision_history"""
 
2275
        history = self._lefthand_history(revision_id, last_rev, other_branch)
 
2276
        revno = len(history)
 
2277
        self.set_last_revision_info(revno, revision_id)
 
2278
 
 
2279
    @needs_read_lock
 
2280
    def get_rev_id(self, revno, history=None):
 
2281
        """Find the revision id of the specified revno."""
 
2282
        if revno == 0:
 
2283
            return _mod_revision.NULL_REVISION
 
2284
 
 
2285
        last_revno, last_revision_id = self.last_revision_info()
 
2286
        if revno <= 0 or revno > last_revno:
 
2287
            raise errors.NoSuchRevision(self, revno)
 
2288
 
 
2289
        if history is not None:
 
2290
            return history[revno - 1]
 
2291
 
 
2292
        index = last_revno - revno
 
2293
        if len(self._partial_revision_history_cache) <= index:
 
2294
            self._extend_partial_history(stop_index=index)
 
2295
        if len(self._partial_revision_history_cache) > index:
 
2296
            return self._partial_revision_history_cache[index]
 
2297
        else:
 
2298
            raise errors.NoSuchRevision(self, revno)
 
2299
 
 
2300
    @needs_read_lock
 
2301
    def revision_id_to_revno(self, revision_id):
 
2302
        """Given a revision id, return its revno"""
 
2303
        if _mod_revision.is_null(revision_id):
 
2304
            return 0
 
2305
        try:
 
2306
            index = self._partial_revision_history_cache.index(revision_id)
 
2307
        except ValueError:
 
2308
            self._extend_partial_history(stop_revision=revision_id)
 
2309
            index = len(self._partial_revision_history_cache) - 1
 
2310
            if self._partial_revision_history_cache[index] != revision_id:
 
2311
                raise errors.NoSuchRevision(self, revision_id)
 
2312
        return self.revno() - index
 
2313
 
 
2314
 
 
2315
class BzrBranch6(BzrBranch7):
 
2316
    """See BzrBranchFormat6 for the capabilities of this branch.
 
2317
 
 
2318
    This subclass of BzrBranch7 disables the new features BzrBranch7 added,
 
2319
    i.e. stacking.
 
2320
    """
 
2321
 
 
2322
    def get_stacked_on_url(self):
 
2323
        raise errors.UnstackableBranchFormat(self._format, self.base)
 
2324
 
 
2325
    def set_stacked_on_url(self, url):
 
2326
        raise errors.UnstackableBranchFormat(self._format, self.base)
 
2327
 
 
2328
 
 
2329
######################################################################
 
2330
# results of operations
 
2331
 
 
2332
 
 
2333
class _Result(object):
 
2334
 
 
2335
    def _show_tag_conficts(self, to_file):
 
2336
        if not getattr(self, 'tag_conflicts', None):
 
2337
            return
 
2338
        to_file.write('Conflicting tags:\n')
 
2339
        for name, value1, value2 in self.tag_conflicts:
 
2340
            to_file.write('    %s\n' % (name, ))
 
2341
 
 
2342
 
 
2343
class PullResult(_Result):
 
2344
    """Result of a Branch.pull operation.
 
2345
 
 
2346
    :ivar old_revno: Revision number before pull.
 
2347
    :ivar new_revno: Revision number after pull.
 
2348
    :ivar old_revid: Tip revision id before pull.
 
2349
    :ivar new_revid: Tip revision id after pull.
 
2350
    :ivar source_branch: Source (local) branch object.
 
2351
    :ivar master_branch: Master branch of the target, or the target if no
 
2352
        Master
 
2353
    :ivar local_branch: target branch if there is a Master, else None
 
2354
    :ivar target_branch: Target/destination branch object.
 
2355
    :ivar tag_conflicts: A list of tag conflicts, see BasicTags.merge_to
 
2356
    """
 
2357
 
 
2358
    def __int__(self):
 
2359
        # DEPRECATED: pull used to return the change in revno
 
2360
        return self.new_revno - self.old_revno
 
2361
 
 
2362
    def report(self, to_file):
 
2363
        if not is_quiet():
 
2364
            if self.old_revid == self.new_revid:
 
2365
                to_file.write('No revisions to pull.\n')
 
2366
            else:
 
2367
                to_file.write('Now on revision %d.\n' % self.new_revno)
 
2368
        self._show_tag_conficts(to_file)
 
2369
 
 
2370
 
 
2371
class PushResult(_Result):
 
2372
    """Result of a Branch.push operation.
 
2373
 
 
2374
    :ivar old_revno: Revision number before push.
 
2375
    :ivar new_revno: Revision number after push.
 
2376
    :ivar old_revid: Tip revision id before push.
 
2377
    :ivar new_revid: Tip revision id after push.
 
2378
    :ivar source_branch: Source branch object.
 
2379
    :ivar master_branch: Master branch of the target, or None.
 
2380
    :ivar target_branch: Target/destination branch object.
 
2381
    """
 
2382
 
 
2383
    def __int__(self):
 
2384
        # DEPRECATED: push used to return the change in revno
 
2385
        return self.new_revno - self.old_revno
 
2386
 
 
2387
    def report(self, to_file):
 
2388
        """Write a human-readable description of the result."""
 
2389
        if self.old_revid == self.new_revid:
 
2390
            to_file.write('No new revisions to push.\n')
 
2391
        else:
 
2392
            to_file.write('Pushed up to revision %d.\n' % self.new_revno)
 
2393
        self._show_tag_conficts(to_file)
 
2394
 
 
2395
 
 
2396
class BranchCheckResult(object):
 
2397
    """Results of checking branch consistency.
 
2398
 
 
2399
    :see: Branch.check
 
2400
    """
 
2401
 
 
2402
    def __init__(self, branch):
 
2403
        self.branch = branch
 
2404
 
 
2405
    def report_results(self, verbose):
 
2406
        """Report the check results via trace.note.
 
2407
        
 
2408
        :param verbose: Requests more detailed display of what was checked,
 
2409
            if any.
 
2410
        """
 
2411
        note('checked branch %s format %s',
 
2412
             self.branch.base,
 
2413
             self.branch._format)
 
2414
 
 
2415
 
 
2416
class Converter5to6(object):
 
2417
    """Perform an in-place upgrade of format 5 to format 6"""
 
2418
 
 
2419
    def convert(self, branch):
 
2420
        # Data for 5 and 6 can peacefully coexist.
 
2421
        format = BzrBranchFormat6()
 
2422
        new_branch = format.open(branch.bzrdir, _found=True)
 
2423
 
 
2424
        # Copy source data into target
 
2425
        new_branch._write_last_revision_info(*branch.last_revision_info())
 
2426
        new_branch.set_parent(branch.get_parent())
 
2427
        new_branch.set_bound_location(branch.get_bound_location())
 
2428
        new_branch.set_push_location(branch.get_push_location())
 
2429
 
 
2430
        # New branch has no tags by default
 
2431
        new_branch.tags._set_tag_dict({})
 
2432
 
 
2433
        # Copying done; now update target format
 
2434
        new_branch._transport.put_bytes('format',
 
2435
            format.get_format_string(),
 
2436
            mode=new_branch.bzrdir._get_file_mode())
 
2437
 
 
2438
        # Clean up old files
 
2439
        new_branch._transport.delete('revision-history')
 
2440
        try:
 
2441
            branch.set_parent(None)
 
2442
        except errors.NoSuchFile:
 
2443
            pass
 
2444
        branch.set_bound_location(None)
 
2445
 
 
2446
 
 
2447
class Converter6to7(object):
 
2448
    """Perform an in-place upgrade of format 6 to format 7"""
 
2449
 
 
2450
    def convert(self, branch):
 
2451
        format = BzrBranchFormat7()
 
2452
        branch._set_config_location('stacked_on_location', '')
 
2453
        # update target format
 
2454
        branch._transport.put_bytes('format', format.get_format_string())