/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: Martin Pool
  • Date: 2007-03-01 04:15:28 UTC
  • mto: (2220.2.48 tags)
  • mto: This revision was merged to the branch mainline in revision 2309.
  • Revision ID: mbp@sourcefrog.net-20070301041528-14my1q8v0buynzut
Add docs for Results, give some members cleaner names

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005, 2006, 2007 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
from cStringIO import StringIO
 
19
 
 
20
from bzrlib.lazy_import import lazy_import
 
21
lazy_import(globals(), """
 
22
from copy import deepcopy
 
23
from unittest import TestSuite
 
24
from warnings import warn
 
25
 
 
26
import bzrlib
 
27
from bzrlib import (
 
28
        bzrdir,
 
29
        cache_utf8,
 
30
        config as _mod_config,
 
31
        errors,
 
32
        lockdir,
 
33
        lockable_files,
 
34
        osutils,
 
35
        revision as _mod_revision,
 
36
        transport,
 
37
        tree,
 
38
        ui,
 
39
        urlutils,
 
40
        )
 
41
from bzrlib.config import BranchConfig, TreeConfig
 
42
from bzrlib.lockable_files import LockableFiles, TransportLock
 
43
""")
 
44
 
 
45
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
46
from bzrlib.errors import (BzrError, BzrCheckError, DivergedBranches,
 
47
                           HistoryMissing, InvalidRevisionId,
 
48
                           InvalidRevisionNumber, LockError, NoSuchFile,
 
49
                           NoSuchRevision, NoWorkingTree, NotVersionedError,
 
50
                           NotBranchError, UninitializableFormat,
 
51
                           UnlistableStore, UnlistableBranch,
 
52
                           )
 
53
from bzrlib.symbol_versioning import (deprecated_function,
 
54
                                      deprecated_method,
 
55
                                      DEPRECATED_PARAMETER,
 
56
                                      deprecated_passed,
 
57
                                      zero_eight, zero_nine,
 
58
                                      )
 
59
from bzrlib.trace import mutter, note
 
60
 
 
61
 
 
62
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
 
63
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
 
64
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
 
65
 
 
66
 
 
67
# TODO: Maybe include checks for common corruption of newlines, etc?
 
68
 
 
69
# TODO: Some operations like log might retrieve the same revisions
 
70
# repeatedly to calculate deltas.  We could perhaps have a weakref
 
71
# cache in memory to make this faster.  In general anything can be
 
72
# cached in memory between lock and unlock operations. .. nb thats
 
73
# what the transaction identity map provides
 
74
 
 
75
 
 
76
######################################################################
 
77
# branch objects
 
78
 
 
79
class Branch(object):
 
80
    """Branch holding a history of revisions.
 
81
 
 
82
    base
 
83
        Base directory/url of the branch.
 
84
 
 
85
    hooks: An instance of BranchHooks.
 
86
    """
 
87
    # this is really an instance variable - FIXME move it there
 
88
    # - RBC 20060112
 
89
    base = None
 
90
 
 
91
    def __init__(self, *ignored, **ignored_too):
 
92
        raise NotImplementedError('The Branch class is abstract')
 
93
 
 
94
    def break_lock(self):
 
95
        """Break a lock if one is present from another instance.
 
96
 
 
97
        Uses the ui factory to ask for confirmation if the lock may be from
 
98
        an active process.
 
99
 
 
100
        This will probe the repository for its lock as well.
 
101
        """
 
102
        self.control_files.break_lock()
 
103
        self.repository.break_lock()
 
104
        master = self.get_master_branch()
 
105
        if master is not None:
 
106
            master.break_lock()
 
107
 
 
108
    @staticmethod
 
109
    @deprecated_method(zero_eight)
 
110
    def open_downlevel(base):
 
111
        """Open a branch which may be of an old format."""
 
112
        return Branch.open(base, _unsupported=True)
 
113
        
 
114
    @staticmethod
 
115
    def open(base, _unsupported=False):
 
116
        """Open the branch rooted at base.
 
117
 
 
118
        For instance, if the branch is at URL/.bzr/branch,
 
119
        Branch.open(URL) -> a Branch instance.
 
120
        """
 
121
        control = bzrdir.BzrDir.open(base, _unsupported)
 
122
        return control.open_branch(_unsupported)
 
123
 
 
124
    @staticmethod
 
125
    def open_containing(url):
 
126
        """Open an existing branch which contains url.
 
127
        
 
128
        This probes for a branch at url, and searches upwards from there.
 
129
 
 
130
        Basically we keep looking up until we find the control directory or
 
131
        run into the root.  If there isn't one, raises NotBranchError.
 
132
        If there is one and it is either an unrecognised format or an unsupported 
 
133
        format, UnknownFormatError or UnsupportedFormatError are raised.
 
134
        If there is one, it is returned, along with the unused portion of url.
 
135
        """
 
136
        control, relpath = bzrdir.BzrDir.open_containing(url)
 
137
        return control.open_branch(), relpath
 
138
 
 
139
    @staticmethod
 
140
    @deprecated_function(zero_eight)
 
141
    def initialize(base):
 
142
        """Create a new working tree and branch, rooted at 'base' (url)
 
143
 
 
144
        NOTE: This will soon be deprecated in favour of creation
 
145
        through a BzrDir.
 
146
        """
 
147
        return bzrdir.BzrDir.create_standalone_workingtree(base).branch
 
148
 
 
149
    @deprecated_function(zero_eight)
 
150
    def setup_caching(self, cache_root):
 
151
        """Subclasses that care about caching should override this, and set
 
152
        up cached stores located under cache_root.
 
153
        
 
154
        NOTE: This is unused.
 
155
        """
 
156
        pass
 
157
 
 
158
    def get_config(self):
 
159
        return BranchConfig(self)
 
160
 
 
161
    def _get_nick(self):
 
162
        return self.get_config().get_nickname()
 
163
 
 
164
    def _set_nick(self, nick):
 
165
        self.get_config().set_user_option('nickname', nick)
 
166
 
 
167
    nick = property(_get_nick, _set_nick)
 
168
 
 
169
    def is_locked(self):
 
170
        raise NotImplementedError(self.is_locked)
 
171
 
 
172
    def lock_write(self):
 
173
        raise NotImplementedError(self.lock_write)
 
174
 
 
175
    def lock_read(self):
 
176
        raise NotImplementedError(self.lock_read)
 
177
 
 
178
    def unlock(self):
 
179
        raise NotImplementedError(self.unlock)
 
180
 
 
181
    def peek_lock_mode(self):
 
182
        """Return lock mode for the Branch: 'r', 'w' or None"""
 
183
        raise NotImplementedError(self.peek_lock_mode)
 
184
 
 
185
    def get_physical_lock_status(self):
 
186
        raise NotImplementedError(self.get_physical_lock_status)
 
187
 
 
188
    def abspath(self, name):
 
189
        """Return absolute filename for something in the branch
 
190
        
 
191
        XXX: Robert Collins 20051017 what is this used for? why is it a branch
 
192
        method and not a tree method.
 
193
        """
 
194
        raise NotImplementedError(self.abspath)
 
195
 
 
196
    def bind(self, other):
 
197
        """Bind the local branch the other branch.
 
198
 
 
199
        :param other: The branch to bind to
 
200
        :type other: Branch
 
201
        """
 
202
        raise errors.UpgradeRequired(self.base)
 
203
 
 
204
    @needs_write_lock
 
205
    def fetch(self, from_branch, last_revision=None, pb=None):
 
206
        """Copy revisions from from_branch into this branch.
 
207
 
 
208
        :param from_branch: Where to copy from.
 
209
        :param last_revision: What revision to stop at (None for at the end
 
210
                              of the branch.
 
211
        :param pb: An optional progress bar to use.
 
212
 
 
213
        Returns the copied revision count and the failed revisions in a tuple:
 
214
        (copied, failures).
 
215
        """
 
216
        if self.base == from_branch.base:
 
217
            return (0, [])
 
218
        if pb is None:
 
219
            nested_pb = ui.ui_factory.nested_progress_bar()
 
220
            pb = nested_pb
 
221
        else:
 
222
            nested_pb = None
 
223
 
 
224
        from_branch.lock_read()
 
225
        try:
 
226
            if last_revision is None:
 
227
                pb.update('get source history')
 
228
                last_revision = from_branch.last_revision()
 
229
                if last_revision is None:
 
230
                    last_revision = _mod_revision.NULL_REVISION
 
231
            return self.repository.fetch(from_branch.repository,
 
232
                                         revision_id=last_revision,
 
233
                                         pb=nested_pb)
 
234
        finally:
 
235
            if nested_pb is not None:
 
236
                nested_pb.finished()
 
237
            from_branch.unlock()
 
238
 
 
239
    def get_bound_location(self):
 
240
        """Return the URL of the branch we are bound to.
 
241
 
 
242
        Older format branches cannot bind, please be sure to use a metadir
 
243
        branch.
 
244
        """
 
245
        return None
 
246
    
 
247
    def get_old_bound_location(self):
 
248
        """Return the URL of the branch we used to be bound to
 
249
        """
 
250
        raise errors.UpgradeRequired(self.base)
 
251
 
 
252
    def get_commit_builder(self, parents, config=None, timestamp=None, 
 
253
                           timezone=None, committer=None, revprops=None, 
 
254
                           revision_id=None):
 
255
        """Obtain a CommitBuilder for this branch.
 
256
        
 
257
        :param parents: Revision ids of the parents of the new revision.
 
258
        :param config: Optional configuration to use.
 
259
        :param timestamp: Optional timestamp recorded for commit.
 
260
        :param timezone: Optional timezone for timestamp.
 
261
        :param committer: Optional committer to set for commit.
 
262
        :param revprops: Optional dictionary of revision properties.
 
263
        :param revision_id: Optional revision id.
 
264
        """
 
265
 
 
266
        if config is None:
 
267
            config = self.get_config()
 
268
        
 
269
        return self.repository.get_commit_builder(self, parents, config,
 
270
            timestamp, timezone, committer, revprops, revision_id)
 
271
 
 
272
    def get_master_branch(self):
 
273
        """Return the branch we are bound to.
 
274
        
 
275
        :return: Either a Branch, or None
 
276
        """
 
277
        return None
 
278
 
 
279
    def get_revision_delta(self, revno):
 
280
        """Return the delta for one revision.
 
281
 
 
282
        The delta is relative to its mainline predecessor, or the
 
283
        empty tree for revision 1.
 
284
        """
 
285
        assert isinstance(revno, int)
 
286
        rh = self.revision_history()
 
287
        if not (1 <= revno <= len(rh)):
 
288
            raise InvalidRevisionNumber(revno)
 
289
        return self.repository.get_revision_delta(rh[revno-1])
 
290
 
 
291
    def get_root_id(self):
 
292
        """Return the id of this branches root"""
 
293
        raise NotImplementedError(self.get_root_id)
 
294
 
 
295
    def print_file(self, file, revision_id):
 
296
        """Print `file` to stdout."""
 
297
        raise NotImplementedError(self.print_file)
 
298
 
 
299
    def append_revision(self, *revision_ids):
 
300
        raise NotImplementedError(self.append_revision)
 
301
 
 
302
    def set_revision_history(self, rev_history):
 
303
        raise NotImplementedError(self.set_revision_history)
 
304
 
 
305
    def revision_history(self):
 
306
        """Return sequence of revision hashes on to this branch."""
 
307
        raise NotImplementedError(self.revision_history)
 
308
 
 
309
    def revno(self):
 
310
        """Return current revision number for this branch.
 
311
 
 
312
        That is equivalent to the number of revisions committed to
 
313
        this branch.
 
314
        """
 
315
        return len(self.revision_history())
 
316
 
 
317
    def unbind(self):
 
318
        """Older format branches cannot bind or unbind."""
 
319
        raise errors.UpgradeRequired(self.base)
 
320
 
 
321
    def set_append_revisions_only(self, enabled):
 
322
        """Older format branches are never restricted to append-only"""
 
323
        raise errors.UpgradeRequired(self.base)
 
324
 
 
325
    def last_revision(self):
 
326
        """Return last revision id, or None"""
 
327
        ph = self.revision_history()
 
328
        if ph:
 
329
            return ph[-1]
 
330
        else:
 
331
            return None
 
332
 
 
333
    def last_revision_info(self):
 
334
        """Return information about the last revision.
 
335
 
 
336
        :return: A tuple (revno, last_revision_id).
 
337
        """
 
338
        rh = self.revision_history()
 
339
        revno = len(rh)
 
340
        if revno:
 
341
            return (revno, rh[-1])
 
342
        else:
 
343
            return (0, _mod_revision.NULL_REVISION)
 
344
 
 
345
    def missing_revisions(self, other, stop_revision=None):
 
346
        """Return a list of new revisions that would perfectly fit.
 
347
        
 
348
        If self and other have not diverged, return a list of the revisions
 
349
        present in other, but missing from self.
 
350
        """
 
351
        self_history = self.revision_history()
 
352
        self_len = len(self_history)
 
353
        other_history = other.revision_history()
 
354
        other_len = len(other_history)
 
355
        common_index = min(self_len, other_len) -1
 
356
        if common_index >= 0 and \
 
357
            self_history[common_index] != other_history[common_index]:
 
358
            raise DivergedBranches(self, other)
 
359
 
 
360
        if stop_revision is None:
 
361
            stop_revision = other_len
 
362
        else:
 
363
            assert isinstance(stop_revision, int)
 
364
            if stop_revision > other_len:
 
365
                raise errors.NoSuchRevision(self, stop_revision)
 
366
        return other_history[self_len:stop_revision]
 
367
 
 
368
    def update_revisions(self, other, stop_revision=None):
 
369
        """Pull in new perfect-fit revisions.
 
370
 
 
371
        :param other: Another Branch to pull from
 
372
        :param stop_revision: Updated until the given revision
 
373
        :return: None
 
374
        """
 
375
        raise NotImplementedError(self.update_revisions)
 
376
 
 
377
    def revision_id_to_revno(self, revision_id):
 
378
        """Given a revision id, return its revno"""
 
379
        if revision_id is None:
 
380
            return 0
 
381
        revision_id = osutils.safe_revision_id(revision_id)
 
382
        history = self.revision_history()
 
383
        try:
 
384
            return history.index(revision_id) + 1
 
385
        except ValueError:
 
386
            raise bzrlib.errors.NoSuchRevision(self, revision_id)
 
387
 
 
388
    def get_rev_id(self, revno, history=None):
 
389
        """Find the revision id of the specified revno."""
 
390
        if revno == 0:
 
391
            return None
 
392
        if history is None:
 
393
            history = self.revision_history()
 
394
        if revno <= 0 or revno > len(history):
 
395
            raise bzrlib.errors.NoSuchRevision(self, revno)
 
396
        return history[revno - 1]
 
397
 
 
398
    def pull(self, source, overwrite=False, stop_revision=None):
 
399
        """Mirror source into this branch.
 
400
 
 
401
        This branch is considered to be 'local', having low latency.
 
402
 
 
403
        :returns: PullResult instance
 
404
        """
 
405
        raise NotImplementedError(self.pull)
 
406
 
 
407
    def push(self, target, overwrite=False, stop_revision=None):
 
408
        """Mirror this branch into target.
 
409
 
 
410
        This branch is considered to be 'local', having low latency.
 
411
        """
 
412
        raise NotImplementedError(self.push)
 
413
 
 
414
    def basis_tree(self):
 
415
        """Return `Tree` object for last revision."""
 
416
        return self.repository.revision_tree(self.last_revision())
 
417
 
 
418
    def rename_one(self, from_rel, to_rel):
 
419
        """Rename one file.
 
420
 
 
421
        This can change the directory or the filename or both.
 
422
        """
 
423
        raise NotImplementedError(self.rename_one)
 
424
 
 
425
    def move(self, from_paths, to_name):
 
426
        """Rename files.
 
427
 
 
428
        to_name must exist as a versioned directory.
 
429
 
 
430
        If to_name exists and is a directory, the files are moved into
 
431
        it, keeping their old names.  If it is a directory, 
 
432
 
 
433
        Note that to_name is only the last component of the new name;
 
434
        this doesn't change the directory.
 
435
 
 
436
        This returns a list of (from_path, to_path) pairs for each
 
437
        entry that is moved.
 
438
        """
 
439
        raise NotImplementedError(self.move)
 
440
 
 
441
    def get_parent(self):
 
442
        """Return the parent location of the branch.
 
443
 
 
444
        This is the default location for push/pull/missing.  The usual
 
445
        pattern is that the user can override it by specifying a
 
446
        location.
 
447
        """
 
448
        raise NotImplementedError(self.get_parent)
 
449
 
 
450
    def get_submit_branch(self):
 
451
        """Return the submit location of the branch.
 
452
 
 
453
        This is the default location for bundle.  The usual
 
454
        pattern is that the user can override it by specifying a
 
455
        location.
 
456
        """
 
457
        return self.get_config().get_user_option('submit_branch')
 
458
 
 
459
    def set_submit_branch(self, location):
 
460
        """Return the submit location of the branch.
 
461
 
 
462
        This is the default location for bundle.  The usual
 
463
        pattern is that the user can override it by specifying a
 
464
        location.
 
465
        """
 
466
        self.get_config().set_user_option('submit_branch', location)
 
467
 
 
468
    def get_push_location(self):
 
469
        """Return the None or the location to push this branch to."""
 
470
        raise NotImplementedError(self.get_push_location)
 
471
 
 
472
    def set_push_location(self, location):
 
473
        """Set a new push location for this branch."""
 
474
        raise NotImplementedError(self.set_push_location)
 
475
 
 
476
    def set_parent(self, url):
 
477
        raise NotImplementedError(self.set_parent)
 
478
 
 
479
    @needs_write_lock
 
480
    def update(self):
 
481
        """Synchronise this branch with the master branch if any. 
 
482
 
 
483
        :return: None or the last_revision pivoted out during the update.
 
484
        """
 
485
        return None
 
486
 
 
487
    def check_revno(self, revno):
 
488
        """\
 
489
        Check whether a revno corresponds to any revision.
 
490
        Zero (the NULL revision) is considered valid.
 
491
        """
 
492
        if revno != 0:
 
493
            self.check_real_revno(revno)
 
494
            
 
495
    def check_real_revno(self, revno):
 
496
        """\
 
497
        Check whether a revno corresponds to a real revision.
 
498
        Zero (the NULL revision) is considered invalid
 
499
        """
 
500
        if revno < 1 or revno > self.revno():
 
501
            raise InvalidRevisionNumber(revno)
 
502
 
 
503
    @needs_read_lock
 
504
    def clone(self, *args, **kwargs):
 
505
        """Clone this branch into to_bzrdir preserving all semantic values.
 
506
        
 
507
        revision_id: if not None, the revision history in the new branch will
 
508
                     be truncated to end with revision_id.
 
509
        """
 
510
        # for API compatibility, until 0.8 releases we provide the old api:
 
511
        # def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
 
512
        # after 0.8 releases, the *args and **kwargs should be changed:
 
513
        # def clone(self, to_bzrdir, revision_id=None):
 
514
        if (kwargs.get('to_location', None) or
 
515
            kwargs.get('revision', None) or
 
516
            kwargs.get('basis_branch', None) or
 
517
            (len(args) and isinstance(args[0], basestring))):
 
518
            # backwards compatibility api:
 
519
            warn("Branch.clone() has been deprecated for BzrDir.clone() from"
 
520
                 " bzrlib 0.8.", DeprecationWarning, stacklevel=3)
 
521
            # get basis_branch
 
522
            if len(args) > 2:
 
523
                basis_branch = args[2]
 
524
            else:
 
525
                basis_branch = kwargs.get('basis_branch', None)
 
526
            if basis_branch:
 
527
                basis = basis_branch.bzrdir
 
528
            else:
 
529
                basis = None
 
530
            # get revision
 
531
            if len(args) > 1:
 
532
                revision_id = args[1]
 
533
            else:
 
534
                revision_id = kwargs.get('revision', None)
 
535
            # get location
 
536
            if len(args):
 
537
                url = args[0]
 
538
            else:
 
539
                # no default to raise if not provided.
 
540
                url = kwargs.get('to_location')
 
541
            return self.bzrdir.clone(url,
 
542
                                     revision_id=revision_id,
 
543
                                     basis=basis).open_branch()
 
544
        # new cleaner api.
 
545
        # generate args by hand 
 
546
        if len(args) > 1:
 
547
            revision_id = args[1]
 
548
        else:
 
549
            revision_id = kwargs.get('revision_id', None)
 
550
        if len(args):
 
551
            to_bzrdir = args[0]
 
552
        else:
 
553
            # no default to raise if not provided.
 
554
            to_bzrdir = kwargs.get('to_bzrdir')
 
555
        result = self._format.initialize(to_bzrdir)
 
556
        self.copy_content_into(result, revision_id=revision_id)
 
557
        return  result
 
558
 
 
559
    @needs_read_lock
 
560
    def sprout(self, to_bzrdir, revision_id=None):
 
561
        """Create a new line of development from the branch, into to_bzrdir.
 
562
        
 
563
        revision_id: if not None, the revision history in the new branch will
 
564
                     be truncated to end with revision_id.
 
565
        """
 
566
        result = self._format.initialize(to_bzrdir)
 
567
        self.copy_content_into(result, revision_id=revision_id)
 
568
        result.set_parent(self.bzrdir.root_transport.base)
 
569
        return result
 
570
 
 
571
    def _synchronize_history(self, destination, revision_id):
 
572
        """Synchronize last revision and revision history between branches.
 
573
 
 
574
        This version is most efficient when the destination is also a
 
575
        BzrBranch5, but works for BzrBranch6 as long as the revision
 
576
        history is the true lefthand parent history, and all of the revisions
 
577
        are in the destination's repository.  If not, set_revision_history
 
578
        will fail.
 
579
 
 
580
        :param destination: The branch to copy the history into
 
581
        :param revision_id: The revision-id to truncate history at.  May
 
582
          be None to copy complete history.
 
583
        """
 
584
        new_history = self.revision_history()
 
585
        if revision_id is not None:
 
586
            revision_id = osutils.safe_revision_id(revision_id)
 
587
            try:
 
588
                new_history = new_history[:new_history.index(revision_id) + 1]
 
589
            except ValueError:
 
590
                rev = self.repository.get_revision(revision_id)
 
591
                new_history = rev.get_history(self.repository)[1:]
 
592
        destination.set_revision_history(new_history)
 
593
 
 
594
    @needs_read_lock
 
595
    def copy_content_into(self, destination, revision_id=None):
 
596
        """Copy the content of self into destination.
 
597
 
 
598
        revision_id: if not None, the revision history in the new branch will
 
599
                     be truncated to end with revision_id.
 
600
        """
 
601
        self._synchronize_history(destination, revision_id)
 
602
        try:
 
603
            parent = self.get_parent()
 
604
        except errors.InaccessibleParent, e:
 
605
            mutter('parent was not accessible to copy: %s', e)
 
606
        else:
 
607
            if parent:
 
608
                destination.set_parent(parent)
 
609
 
 
610
    @needs_read_lock
 
611
    def check(self):
 
612
        """Check consistency of the branch.
 
613
 
 
614
        In particular this checks that revisions given in the revision-history
 
615
        do actually match up in the revision graph, and that they're all 
 
616
        present in the repository.
 
617
        
 
618
        Callers will typically also want to check the repository.
 
619
 
 
620
        :return: A BranchCheckResult.
 
621
        """
 
622
        mainline_parent_id = None
 
623
        for revision_id in self.revision_history():
 
624
            try:
 
625
                revision = self.repository.get_revision(revision_id)
 
626
            except errors.NoSuchRevision, e:
 
627
                raise errors.BzrCheckError("mainline revision {%s} not in repository"
 
628
                            % revision_id)
 
629
            # In general the first entry on the revision history has no parents.
 
630
            # But it's not illegal for it to have parents listed; this can happen
 
631
            # in imports from Arch when the parents weren't reachable.
 
632
            if mainline_parent_id is not None:
 
633
                if mainline_parent_id not in revision.parent_ids:
 
634
                    raise errors.BzrCheckError("previous revision {%s} not listed among "
 
635
                                        "parents of {%s}"
 
636
                                        % (mainline_parent_id, revision_id))
 
637
            mainline_parent_id = revision_id
 
638
        return BranchCheckResult(self)
 
639
 
 
640
    def _get_checkout_format(self):
 
641
        """Return the most suitable metadir for a checkout of this branch.
 
642
        Weaves are used if this branch's repostory uses weaves.
 
643
        """
 
644
        if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):
 
645
            from bzrlib.repofmt import weaverepo
 
646
            format = bzrdir.BzrDirMetaFormat1()
 
647
            format.repository_format = weaverepo.RepositoryFormat7()
 
648
        else:
 
649
            format = self.repository.bzrdir.cloning_metadir()
 
650
            format.branch_format = self._format
 
651
        return format
 
652
 
 
653
    def create_checkout(self, to_location, revision_id=None,
 
654
                        lightweight=False):
 
655
        """Create a checkout of a branch.
 
656
        
 
657
        :param to_location: The url to produce the checkout at
 
658
        :param revision_id: The revision to check out
 
659
        :param lightweight: If True, produce a lightweight checkout, otherwise,
 
660
        produce a bound branch (heavyweight checkout)
 
661
        :return: The tree of the created checkout
 
662
        """
 
663
        t = transport.get_transport(to_location)
 
664
        try:
 
665
            t.mkdir('.')
 
666
        except errors.FileExists:
 
667
            pass
 
668
        if lightweight:
 
669
            checkout = bzrdir.BzrDirMetaFormat1().initialize_on_transport(t)
 
670
            BranchReferenceFormat().initialize(checkout, self)
 
671
        else:
 
672
            format = self._get_checkout_format()
 
673
            checkout_branch = bzrdir.BzrDir.create_branch_convenience(
 
674
                to_location, force_new_tree=False, format=format)
 
675
            checkout = checkout_branch.bzrdir
 
676
            checkout_branch.bind(self)
 
677
            # pull up to the specified revision_id to set the initial 
 
678
            # branch tip correctly, and seed it with history.
 
679
            checkout_branch.pull(self, stop_revision=revision_id)
 
680
        return checkout.create_workingtree(revision_id)
 
681
 
 
682
 
 
683
class BranchFormat(object):
 
684
    """An encapsulation of the initialization and open routines for a format.
 
685
 
 
686
    Formats provide three things:
 
687
     * An initialization routine,
 
688
     * a format string,
 
689
     * an open routine.
 
690
 
 
691
    Formats are placed in an dict by their format string for reference 
 
692
    during branch opening. Its not required that these be instances, they
 
693
    can be classes themselves with class methods - it simply depends on 
 
694
    whether state is needed for a given format or not.
 
695
 
 
696
    Once a format is deprecated, just deprecate the initialize and open
 
697
    methods on the format class. Do not deprecate the object, as the 
 
698
    object will be created every time regardless.
 
699
    """
 
700
 
 
701
    _default_format = None
 
702
    """The default format used for new branches."""
 
703
 
 
704
    _formats = {}
 
705
    """The known formats."""
 
706
 
 
707
    @classmethod
 
708
    def find_format(klass, a_bzrdir):
 
709
        """Return the format for the branch object in a_bzrdir."""
 
710
        try:
 
711
            transport = a_bzrdir.get_branch_transport(None)
 
712
            format_string = transport.get("format").read()
 
713
            return klass._formats[format_string]
 
714
        except NoSuchFile:
 
715
            raise NotBranchError(path=transport.base)
 
716
        except KeyError:
 
717
            raise errors.UnknownFormatError(format=format_string)
 
718
 
 
719
    @classmethod
 
720
    def get_default_format(klass):
 
721
        """Return the current default format."""
 
722
        return klass._default_format
 
723
 
 
724
    def get_format_string(self):
 
725
        """Return the ASCII format string that identifies this format."""
 
726
        raise NotImplementedError(self.get_format_string)
 
727
 
 
728
    def get_format_description(self):
 
729
        """Return the short format description for this format."""
 
730
        raise NotImplementedError(self.get_format_description)
 
731
 
 
732
    def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
 
733
                           set_format=True):
 
734
        """Initialize a branch in a bzrdir, with specified files
 
735
 
 
736
        :param a_bzrdir: The bzrdir to initialize the branch in
 
737
        :param utf8_files: The files to create as a list of
 
738
            (filename, content) tuples
 
739
        :param set_format: If True, set the format with
 
740
            self.get_format_string.  (BzrBranch4 has its format set
 
741
            elsewhere)
 
742
        :return: a branch in this format
 
743
        """
 
744
        mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
 
745
        branch_transport = a_bzrdir.get_branch_transport(self)
 
746
        lock_map = {
 
747
            'metadir': ('lock', lockdir.LockDir),
 
748
            'branch4': ('branch-lock', lockable_files.TransportLock),
 
749
        }
 
750
        lock_name, lock_class = lock_map[lock_type]
 
751
        control_files = lockable_files.LockableFiles(branch_transport,
 
752
            lock_name, lock_class)
 
753
        control_files.create_lock()
 
754
        control_files.lock_write()
 
755
        if set_format:
 
756
            control_files.put_utf8('format', self.get_format_string())
 
757
        try:
 
758
            for file, content in utf8_files:
 
759
                control_files.put_utf8(file, content)
 
760
        finally:
 
761
            control_files.unlock()
 
762
        return self.open(a_bzrdir, _found=True)
 
763
 
 
764
    def initialize(self, a_bzrdir):
 
765
        """Create a branch of this format in a_bzrdir."""
 
766
        raise NotImplementedError(self.initialize)
 
767
 
 
768
    def is_supported(self):
 
769
        """Is this format supported?
 
770
 
 
771
        Supported formats can be initialized and opened.
 
772
        Unsupported formats may not support initialization or committing or 
 
773
        some other features depending on the reason for not being supported.
 
774
        """
 
775
        return True
 
776
 
 
777
    def open(self, a_bzrdir, _found=False):
 
778
        """Return the branch object for a_bzrdir
 
779
 
 
780
        _found is a private parameter, do not use it. It is used to indicate
 
781
               if format probing has already be done.
 
782
        """
 
783
        raise NotImplementedError(self.open)
 
784
 
 
785
    @classmethod
 
786
    def register_format(klass, format):
 
787
        klass._formats[format.get_format_string()] = format
 
788
 
 
789
    @classmethod
 
790
    def set_default_format(klass, format):
 
791
        klass._default_format = format
 
792
 
 
793
    @classmethod
 
794
    def unregister_format(klass, format):
 
795
        assert klass._formats[format.get_format_string()] is format
 
796
        del klass._formats[format.get_format_string()]
 
797
 
 
798
    def __str__(self):
 
799
        return self.get_format_string().rstrip()
 
800
 
 
801
 
 
802
class BranchHooks(dict):
 
803
    """A dictionary mapping hook name to a list of callables for branch hooks.
 
804
    
 
805
    e.g. ['set_rh'] Is the list of items to be called when the
 
806
    set_revision_history function is invoked.
 
807
    """
 
808
 
 
809
    def __init__(self):
 
810
        """Create the default hooks.
 
811
 
 
812
        These are all empty initially, because by default nothing should get
 
813
        notified.
 
814
        """
 
815
        dict.__init__(self)
 
816
        # Introduced in 0.15:
 
817
        # invoked whenever the revision history has been set
 
818
        # with set_revision_history. The api signature is
 
819
        # (branch, revision_history), and the branch will
 
820
        # be write-locked.
 
821
        self['set_rh'] = []
 
822
        # invoked after a push operation completes.
 
823
        # the api signature is
 
824
        # (push_result)
 
825
        # containing the members
 
826
        # (source, local, master, old_revno, old_revid, new_revno, new_revid)
 
827
        # where local is the local branch or None, master is the target 
 
828
        # master branch, and the rest should be self explanatory. The source
 
829
        # is read locked and the target branches write locked. Source will
 
830
        # be the local low-latency branch.
 
831
        self['post_push'] = []
 
832
        # invoked after a pull operation completes.
 
833
        # the api signature is
 
834
        # (pull_result)
 
835
        # containing the members
 
836
        # (source, local, master, old_revno, old_revid, new_revno, new_revid)
 
837
        # where local is the local branch or None, master is the target 
 
838
        # master branch, and the rest should be self explanatory. The source
 
839
        # is read locked and the target branches write locked. The local
 
840
        # branch is the low-latency branch.
 
841
        self['post_pull'] = []
 
842
        # invoked after a commit operation completes.
 
843
        # the api signature is 
 
844
        # (local, master, old_revno, old_revid, new_revno, new_revid)
 
845
        # old_revid is NULL_REVISION for the first commit to a branch.
 
846
        self['post_commit'] = []
 
847
        # invoked after a uncommit operation completes.
 
848
        # the api signature is
 
849
        # (local, master, old_revno, old_revid, new_revno, new_revid) where
 
850
        # local is the local branch or None, master is the target branch,
 
851
        # and an empty branch recieves new_revno of 0, new_revid of None.
 
852
        self['post_uncommit'] = []
 
853
 
 
854
    def install_hook(self, hook_name, a_callable):
 
855
        """Install a_callable in to the hook hook_name.
 
856
 
 
857
        :param hook_name: A hook name. See the __init__ method of BranchHooks
 
858
            for the complete list of hooks.
 
859
        :param a_callable: The callable to be invoked when the hook triggers.
 
860
            The exact signature will depend on the hook - see the __init__ 
 
861
            method of BranchHooks for details on each hook.
 
862
        """
 
863
        try:
 
864
            self[hook_name].append(a_callable)
 
865
        except KeyError:
 
866
            raise errors.UnknownHook('branch', hook_name)
 
867
 
 
868
 
 
869
# install the default hooks into the Branch class.
 
870
Branch.hooks = BranchHooks()
 
871
 
 
872
 
 
873
class BzrBranchFormat4(BranchFormat):
 
874
    """Bzr branch format 4.
 
875
 
 
876
    This format has:
 
877
     - a revision-history file.
 
878
     - a branch-lock lock file [ to be shared with the bzrdir ]
 
879
    """
 
880
 
 
881
    def get_format_description(self):
 
882
        """See BranchFormat.get_format_description()."""
 
883
        return "Branch format 4"
 
884
 
 
885
    def initialize(self, a_bzrdir):
 
886
        """Create a branch of this format in a_bzrdir."""
 
887
        utf8_files = [('revision-history', ''),
 
888
                      ('branch-name', ''),
 
889
                      ]
 
890
        return self._initialize_helper(a_bzrdir, utf8_files,
 
891
                                       lock_type='branch4', set_format=False)
 
892
 
 
893
    def __init__(self):
 
894
        super(BzrBranchFormat4, self).__init__()
 
895
        self._matchingbzrdir = bzrdir.BzrDirFormat6()
 
896
 
 
897
    def open(self, a_bzrdir, _found=False):
 
898
        """Return the branch object for a_bzrdir
 
899
 
 
900
        _found is a private parameter, do not use it. It is used to indicate
 
901
               if format probing has already be done.
 
902
        """
 
903
        if not _found:
 
904
            # we are being called directly and must probe.
 
905
            raise NotImplementedError
 
906
        return BzrBranch(_format=self,
 
907
                         _control_files=a_bzrdir._control_files,
 
908
                         a_bzrdir=a_bzrdir,
 
909
                         _repository=a_bzrdir.open_repository())
 
910
 
 
911
    def __str__(self):
 
912
        return "Bazaar-NG branch format 4"
 
913
 
 
914
 
 
915
class BzrBranchFormat5(BranchFormat):
 
916
    """Bzr branch format 5.
 
917
 
 
918
    This format has:
 
919
     - a revision-history file.
 
920
     - a format string
 
921
     - a lock dir guarding the branch itself
 
922
     - all of this stored in a branch/ subdirectory
 
923
     - works with shared repositories.
 
924
 
 
925
    This format is new in bzr 0.8.
 
926
    """
 
927
 
 
928
    def get_format_string(self):
 
929
        """See BranchFormat.get_format_string()."""
 
930
        return "Bazaar-NG branch format 5\n"
 
931
 
 
932
    def get_format_description(self):
 
933
        """See BranchFormat.get_format_description()."""
 
934
        return "Branch format 5"
 
935
        
 
936
    def initialize(self, a_bzrdir):
 
937
        """Create a branch of this format in a_bzrdir."""
 
938
        utf8_files = [('revision-history', ''),
 
939
                      ('branch-name', ''),
 
940
                      ]
 
941
        return self._initialize_helper(a_bzrdir, utf8_files)
 
942
 
 
943
    def __init__(self):
 
944
        super(BzrBranchFormat5, self).__init__()
 
945
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
 
946
 
 
947
    def open(self, a_bzrdir, _found=False):
 
948
        """Return the branch object for a_bzrdir
 
949
 
 
950
        _found is a private parameter, do not use it. It is used to indicate
 
951
               if format probing has already be done.
 
952
        """
 
953
        if not _found:
 
954
            format = BranchFormat.find_format(a_bzrdir)
 
955
            assert format.__class__ == self.__class__
 
956
        transport = a_bzrdir.get_branch_transport(None)
 
957
        control_files = lockable_files.LockableFiles(transport, 'lock',
 
958
                                                     lockdir.LockDir)
 
959
        return BzrBranch5(_format=self,
 
960
                          _control_files=control_files,
 
961
                          a_bzrdir=a_bzrdir,
 
962
                          _repository=a_bzrdir.find_repository())
 
963
 
 
964
    def __str__(self):
 
965
        return "Bazaar-NG Metadir branch format 5"
 
966
 
 
967
 
 
968
class BzrBranchFormat6(BzrBranchFormat5):
 
969
    """Branch format with last-revision
 
970
 
 
971
    Unlike previous formats, this has no explicit revision history. Instead,
 
972
    this just stores the last-revision, and the left-hand history leading
 
973
    up to there is the history.
 
974
 
 
975
    This format was introduced in bzr 0.15
 
976
    """
 
977
 
 
978
    def get_format_string(self):
 
979
        """See BranchFormat.get_format_string()."""
 
980
        return "Bazaar-NG branch format 6\n"
 
981
 
 
982
    def get_format_description(self):
 
983
        """See BranchFormat.get_format_description()."""
 
984
        return "Branch format 6"
 
985
 
 
986
    def initialize(self, a_bzrdir):
 
987
        """Create a branch of this format in a_bzrdir."""
 
988
        utf8_files = [('last-revision', '0 null:\n'),
 
989
                      ('branch-name', ''),
 
990
                      ('branch.conf', '')
 
991
                      ]
 
992
        return self._initialize_helper(a_bzrdir, utf8_files)
 
993
 
 
994
    def open(self, a_bzrdir, _found=False):
 
995
        """Return the branch object for a_bzrdir
 
996
 
 
997
        _found is a private parameter, do not use it. It is used to indicate
 
998
               if format probing has already be done.
 
999
        """
 
1000
        if not _found:
 
1001
            format = BranchFormat.find_format(a_bzrdir)
 
1002
            assert format.__class__ == self.__class__
 
1003
        transport = a_bzrdir.get_branch_transport(None)
 
1004
        control_files = lockable_files.LockableFiles(transport, 'lock',
 
1005
                                                     lockdir.LockDir)
 
1006
        return BzrBranch6(_format=self,
 
1007
                          _control_files=control_files,
 
1008
                          a_bzrdir=a_bzrdir,
 
1009
                          _repository=a_bzrdir.find_repository())
 
1010
 
 
1011
 
 
1012
class BranchReferenceFormat(BranchFormat):
 
1013
    """Bzr branch reference format.
 
1014
 
 
1015
    Branch references are used in implementing checkouts, they
 
1016
    act as an alias to the real branch which is at some other url.
 
1017
 
 
1018
    This format has:
 
1019
     - A location file
 
1020
     - a format string
 
1021
    """
 
1022
 
 
1023
    def get_format_string(self):
 
1024
        """See BranchFormat.get_format_string()."""
 
1025
        return "Bazaar-NG Branch Reference Format 1\n"
 
1026
 
 
1027
    def get_format_description(self):
 
1028
        """See BranchFormat.get_format_description()."""
 
1029
        return "Checkout reference format 1"
 
1030
        
 
1031
    def initialize(self, a_bzrdir, target_branch=None):
 
1032
        """Create a branch of this format in a_bzrdir."""
 
1033
        if target_branch is None:
 
1034
            # this format does not implement branch itself, thus the implicit
 
1035
            # creation contract must see it as uninitializable
 
1036
            raise errors.UninitializableFormat(self)
 
1037
        mutter('creating branch reference in %s', a_bzrdir.transport.base)
 
1038
        branch_transport = a_bzrdir.get_branch_transport(self)
 
1039
        branch_transport.put_bytes('location',
 
1040
            target_branch.bzrdir.root_transport.base)
 
1041
        branch_transport.put_bytes('format', self.get_format_string())
 
1042
        return self.open(a_bzrdir, _found=True)
 
1043
 
 
1044
    def __init__(self):
 
1045
        super(BranchReferenceFormat, self).__init__()
 
1046
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
 
1047
 
 
1048
    def _make_reference_clone_function(format, a_branch):
 
1049
        """Create a clone() routine for a branch dynamically."""
 
1050
        def clone(to_bzrdir, revision_id=None):
 
1051
            """See Branch.clone()."""
 
1052
            return format.initialize(to_bzrdir, a_branch)
 
1053
            # cannot obey revision_id limits when cloning a reference ...
 
1054
            # FIXME RBC 20060210 either nuke revision_id for clone, or
 
1055
            # emit some sort of warning/error to the caller ?!
 
1056
        return clone
 
1057
 
 
1058
    def open(self, a_bzrdir, _found=False):
 
1059
        """Return the branch that the branch reference in a_bzrdir points at.
 
1060
 
 
1061
        _found is a private parameter, do not use it. It is used to indicate
 
1062
               if format probing has already be done.
 
1063
        """
 
1064
        if not _found:
 
1065
            format = BranchFormat.find_format(a_bzrdir)
 
1066
            assert format.__class__ == self.__class__
 
1067
        transport = a_bzrdir.get_branch_transport(None)
 
1068
        real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
 
1069
        result = real_bzrdir.open_branch()
 
1070
        # this changes the behaviour of result.clone to create a new reference
 
1071
        # rather than a copy of the content of the branch.
 
1072
        # I did not use a proxy object because that needs much more extensive
 
1073
        # testing, and we are only changing one behaviour at the moment.
 
1074
        # If we decide to alter more behaviours - i.e. the implicit nickname
 
1075
        # then this should be refactored to introduce a tested proxy branch
 
1076
        # and a subclass of that for use in overriding clone() and ....
 
1077
        # - RBC 20060210
 
1078
        result.clone = self._make_reference_clone_function(result)
 
1079
        return result
 
1080
 
 
1081
 
 
1082
# formats which have no format string are not discoverable
 
1083
# and not independently creatable, so are not registered.
 
1084
__default_format = BzrBranchFormat5()
 
1085
BranchFormat.register_format(__default_format)
 
1086
BranchFormat.register_format(BranchReferenceFormat())
 
1087
BranchFormat.register_format(BzrBranchFormat6())
 
1088
BranchFormat.set_default_format(__default_format)
 
1089
_legacy_formats = [BzrBranchFormat4(),
 
1090
                   ]
 
1091
 
 
1092
class BzrBranch(Branch):
 
1093
    """A branch stored in the actual filesystem.
 
1094
 
 
1095
    Note that it's "local" in the context of the filesystem; it doesn't
 
1096
    really matter if it's on an nfs/smb/afs/coda/... share, as long as
 
1097
    it's writable, and can be accessed via the normal filesystem API.
 
1098
    """
 
1099
    
 
1100
    def __init__(self, transport=DEPRECATED_PARAMETER, init=DEPRECATED_PARAMETER,
 
1101
                 relax_version_check=DEPRECATED_PARAMETER, _format=None,
 
1102
                 _control_files=None, a_bzrdir=None, _repository=None):
 
1103
        """Create new branch object at a particular location.
 
1104
 
 
1105
        transport -- A Transport object, defining how to access files.
 
1106
        
 
1107
        init -- If True, create new control files in a previously
 
1108
             unversioned directory.  If False, the branch must already
 
1109
             be versioned.
 
1110
 
 
1111
        relax_version_check -- If true, the usual check for the branch
 
1112
            version is not applied.  This is intended only for
 
1113
            upgrade/recovery type use; it's not guaranteed that
 
1114
            all operations will work on old format branches.
 
1115
        """
 
1116
        if a_bzrdir is None:
 
1117
            self.bzrdir = bzrdir.BzrDir.open(transport.base)
 
1118
        else:
 
1119
            self.bzrdir = a_bzrdir
 
1120
        self._transport = self.bzrdir.transport.clone('..')
 
1121
        self._base = self._transport.base
 
1122
        self._format = _format
 
1123
        if _control_files is None:
 
1124
            raise ValueError('BzrBranch _control_files is None')
 
1125
        self.control_files = _control_files
 
1126
        if deprecated_passed(init):
 
1127
            warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
 
1128
                 "deprecated as of bzr 0.8. Please use Branch.create().",
 
1129
                 DeprecationWarning,
 
1130
                 stacklevel=2)
 
1131
            if init:
 
1132
                # this is slower than before deprecation, oh well never mind.
 
1133
                # -> its deprecated.
 
1134
                self._initialize(transport.base)
 
1135
        self._check_format(_format)
 
1136
        if deprecated_passed(relax_version_check):
 
1137
            warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
 
1138
                 "relax_version_check parameter is deprecated as of bzr 0.8. "
 
1139
                 "Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
 
1140
                 "open() method.",
 
1141
                 DeprecationWarning,
 
1142
                 stacklevel=2)
 
1143
            if (not relax_version_check
 
1144
                and not self._format.is_supported()):
 
1145
                raise errors.UnsupportedFormatError(format=fmt)
 
1146
        if deprecated_passed(transport):
 
1147
            warn("BzrBranch.__init__(transport=XXX...): The transport "
 
1148
                 "parameter is deprecated as of bzr 0.8. "
 
1149
                 "Please use Branch.open, or bzrdir.open_branch().",
 
1150
                 DeprecationWarning,
 
1151
                 stacklevel=2)
 
1152
        self.repository = _repository
 
1153
 
 
1154
    def __str__(self):
 
1155
        return '%s(%r)' % (self.__class__.__name__, self.base)
 
1156
 
 
1157
    __repr__ = __str__
 
1158
 
 
1159
    def _get_base(self):
 
1160
        return self._base
 
1161
 
 
1162
    base = property(_get_base, doc="The URL for the root of this branch.")
 
1163
 
 
1164
    def _finish_transaction(self):
 
1165
        """Exit the current transaction."""
 
1166
        return self.control_files._finish_transaction()
 
1167
 
 
1168
    def get_transaction(self):
 
1169
        """Return the current active transaction.
 
1170
 
 
1171
        If no transaction is active, this returns a passthrough object
 
1172
        for which all data is immediately flushed and no caching happens.
 
1173
        """
 
1174
        # this is an explicit function so that we can do tricky stuff
 
1175
        # when the storage in rev_storage is elsewhere.
 
1176
        # we probably need to hook the two 'lock a location' and 
 
1177
        # 'have a transaction' together more delicately, so that
 
1178
        # we can have two locks (branch and storage) and one transaction
 
1179
        # ... and finishing the transaction unlocks both, but unlocking
 
1180
        # does not. - RBC 20051121
 
1181
        return self.control_files.get_transaction()
 
1182
 
 
1183
    def _set_transaction(self, transaction):
 
1184
        """Set a new active transaction."""
 
1185
        return self.control_files._set_transaction(transaction)
 
1186
 
 
1187
    def abspath(self, name):
 
1188
        """See Branch.abspath."""
 
1189
        return self.control_files._transport.abspath(name)
 
1190
 
 
1191
    def _check_format(self, format):
 
1192
        """Identify the branch format if needed.
 
1193
 
 
1194
        The format is stored as a reference to the format object in
 
1195
        self._format for code that needs to check it later.
 
1196
 
 
1197
        The format parameter is either None or the branch format class
 
1198
        used to open this branch.
 
1199
 
 
1200
        FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
 
1201
        """
 
1202
        if format is None:
 
1203
            format = BranchFormat.find_format(self.bzrdir)
 
1204
        self._format = format
 
1205
        mutter("got branch format %s", self._format)
 
1206
 
 
1207
    @needs_read_lock
 
1208
    def get_root_id(self):
 
1209
        """See Branch.get_root_id."""
 
1210
        tree = self.repository.revision_tree(self.last_revision())
 
1211
        return tree.inventory.root.file_id
 
1212
 
 
1213
    def is_locked(self):
 
1214
        return self.control_files.is_locked()
 
1215
 
 
1216
    def lock_write(self):
 
1217
        self.repository.lock_write()
 
1218
        try:
 
1219
            self.control_files.lock_write()
 
1220
        except:
 
1221
            self.repository.unlock()
 
1222
            raise
 
1223
 
 
1224
    def lock_read(self):
 
1225
        self.repository.lock_read()
 
1226
        try:
 
1227
            self.control_files.lock_read()
 
1228
        except:
 
1229
            self.repository.unlock()
 
1230
            raise
 
1231
 
 
1232
    def unlock(self):
 
1233
        # TODO: test for failed two phase locks. This is known broken.
 
1234
        try:
 
1235
            self.control_files.unlock()
 
1236
        finally:
 
1237
            self.repository.unlock()
 
1238
        
 
1239
    def peek_lock_mode(self):
 
1240
        if self.control_files._lock_count == 0:
 
1241
            return None
 
1242
        else:
 
1243
            return self.control_files._lock_mode
 
1244
 
 
1245
    def get_physical_lock_status(self):
 
1246
        return self.control_files.get_physical_lock_status()
 
1247
 
 
1248
    @needs_read_lock
 
1249
    def print_file(self, file, revision_id):
 
1250
        """See Branch.print_file."""
 
1251
        return self.repository.print_file(file, revision_id)
 
1252
 
 
1253
    @needs_write_lock
 
1254
    def append_revision(self, *revision_ids):
 
1255
        """See Branch.append_revision."""
 
1256
        revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
 
1257
        for revision_id in revision_ids:
 
1258
            _mod_revision.check_not_reserved_id(revision_id)
 
1259
            mutter("add {%s} to revision-history" % revision_id)
 
1260
        rev_history = self.revision_history()
 
1261
        rev_history.extend(revision_ids)
 
1262
        self.set_revision_history(rev_history)
 
1263
 
 
1264
    def _write_revision_history(self, history):
 
1265
        """Factored out of set_revision_history.
 
1266
 
 
1267
        This performs the actual writing to disk.
 
1268
        It is intended to be called by BzrBranch5.set_revision_history."""
 
1269
        self.control_files.put_bytes(
 
1270
            'revision-history', '\n'.join(history))
 
1271
 
 
1272
    @needs_write_lock
 
1273
    def set_revision_history(self, rev_history):
 
1274
        """See Branch.set_revision_history."""
 
1275
        rev_history = [osutils.safe_revision_id(r) for r in rev_history]
 
1276
        self._write_revision_history(rev_history)
 
1277
        transaction = self.get_transaction()
 
1278
        history = transaction.map.find_revision_history()
 
1279
        if history is not None:
 
1280
            # update the revision history in the identity map.
 
1281
            history[:] = list(rev_history)
 
1282
            # this call is disabled because revision_history is 
 
1283
            # not really an object yet, and the transaction is for objects.
 
1284
            # transaction.register_dirty(history)
 
1285
        else:
 
1286
            transaction.map.add_revision_history(rev_history)
 
1287
            # this call is disabled because revision_history is 
 
1288
            # not really an object yet, and the transaction is for objects.
 
1289
            # transaction.register_clean(history)
 
1290
        for hook in Branch.hooks['set_rh']:
 
1291
            hook(self, rev_history)
 
1292
 
 
1293
    @needs_write_lock
 
1294
    def set_last_revision_info(self, revno, revision_id):
 
1295
        revision_id = osutils.safe_revision_id(revision_id)
 
1296
        history = self._lefthand_history(revision_id)
 
1297
        assert len(history) == revno, '%d != %d' % (len(history), revno)
 
1298
        self.set_revision_history(history)
 
1299
 
 
1300
    def _gen_revision_history(self):
 
1301
        get_cached_utf8 = cache_utf8.get_cached_utf8
 
1302
        history = [get_cached_utf8(l.rstrip('\r\n')) for l in
 
1303
                self.control_files.get('revision-history').readlines()]
 
1304
        return history
 
1305
 
 
1306
    @needs_read_lock
 
1307
    def revision_history(self):
 
1308
        """See Branch.revision_history."""
 
1309
        transaction = self.get_transaction()
 
1310
        history = transaction.map.find_revision_history()
 
1311
        if history is not None:
 
1312
            # mutter("cache hit for revision-history in %s", self)
 
1313
            return list(history)
 
1314
        history = self._gen_revision_history()
 
1315
        transaction.map.add_revision_history(history)
 
1316
        # this call is disabled because revision_history is 
 
1317
        # not really an object yet, and the transaction is for objects.
 
1318
        # transaction.register_clean(history, precious=True)
 
1319
        return list(history)
 
1320
 
 
1321
    def _lefthand_history(self, revision_id, last_rev=None,
 
1322
                          other_branch=None):
 
1323
        # stop_revision must be a descendant of last_revision
 
1324
        stop_graph = self.repository.get_revision_graph(revision_id)
 
1325
        if last_rev is not None and last_rev not in stop_graph:
 
1326
            # our previous tip is not merged into stop_revision
 
1327
            raise errors.DivergedBranches(self, other_branch)
 
1328
        # make a new revision history from the graph
 
1329
        current_rev_id = revision_id
 
1330
        new_history = []
 
1331
        while current_rev_id not in (None, _mod_revision.NULL_REVISION):
 
1332
            new_history.append(current_rev_id)
 
1333
            current_rev_id_parents = stop_graph[current_rev_id]
 
1334
            try:
 
1335
                current_rev_id = current_rev_id_parents[0]
 
1336
            except IndexError:
 
1337
                current_rev_id = None
 
1338
        new_history.reverse()
 
1339
        return new_history
 
1340
 
 
1341
    @needs_write_lock
 
1342
    def generate_revision_history(self, revision_id, last_rev=None,
 
1343
        other_branch=None):
 
1344
        """Create a new revision history that will finish with revision_id.
 
1345
 
 
1346
        :param revision_id: the new tip to use.
 
1347
        :param last_rev: The previous last_revision. If not None, then this
 
1348
            must be a ancestory of revision_id, or DivergedBranches is raised.
 
1349
        :param other_branch: The other branch that DivergedBranches should
 
1350
            raise with respect to.
 
1351
        """
 
1352
        revision_id = osutils.safe_revision_id(revision_id)
 
1353
        self.set_revision_history(self._lefthand_history(revision_id,
 
1354
            last_rev, other_branch))
 
1355
 
 
1356
    @needs_write_lock
 
1357
    def update_revisions(self, other, stop_revision=None):
 
1358
        """See Branch.update_revisions."""
 
1359
        other.lock_read()
 
1360
        try:
 
1361
            if stop_revision is None:
 
1362
                stop_revision = other.last_revision()
 
1363
                if stop_revision is None:
 
1364
                    # if there are no commits, we're done.
 
1365
                    return
 
1366
            else:
 
1367
                stop_revision = osutils.safe_revision_id(stop_revision)
 
1368
            # whats the current last revision, before we fetch [and change it
 
1369
            # possibly]
 
1370
            last_rev = self.last_revision()
 
1371
            # we fetch here regardless of whether we need to so that we pickup
 
1372
            # filled in ghosts.
 
1373
            self.fetch(other, stop_revision)
 
1374
            my_ancestry = self.repository.get_ancestry(last_rev)
 
1375
            if stop_revision in my_ancestry:
 
1376
                # last_revision is a descendant of stop_revision
 
1377
                return
 
1378
            self.generate_revision_history(stop_revision, last_rev=last_rev,
 
1379
                other_branch=other)
 
1380
        finally:
 
1381
            other.unlock()
 
1382
 
 
1383
    def basis_tree(self):
 
1384
        """See Branch.basis_tree."""
 
1385
        return self.repository.revision_tree(self.last_revision())
 
1386
 
 
1387
    @deprecated_method(zero_eight)
 
1388
    def working_tree(self):
 
1389
        """Create a Working tree object for this branch."""
 
1390
 
 
1391
        from bzrlib.transport.local import LocalTransport
 
1392
        if (self.base.find('://') != -1 or 
 
1393
            not isinstance(self._transport, LocalTransport)):
 
1394
            raise NoWorkingTree(self.base)
 
1395
        return self.bzrdir.open_workingtree()
 
1396
 
 
1397
    @needs_write_lock
 
1398
    def pull(self, source, overwrite=False, stop_revision=None,
 
1399
        _hook_master=None, _run_hooks=True):
 
1400
        """See Branch.pull.
 
1401
 
 
1402
        :param _hook_master: Private parameter - set the branch to 
 
1403
            be supplied as the master to push hooks.
 
1404
        :param _run_hooks: Private parameter - allow disabling of
 
1405
            hooks, used when pushing to a master branch.
 
1406
        """
 
1407
        result = PullResult()
 
1408
        result.source_branch = source
 
1409
        result.target_branch = self
 
1410
        source.lock_read()
 
1411
        try:
 
1412
            result.old_revno, result.old_revid = self.last_revision_info()
 
1413
            try:
 
1414
                self.update_revisions(source, stop_revision)
 
1415
            except DivergedBranches:
 
1416
                if not overwrite:
 
1417
                    raise
 
1418
            if overwrite:
 
1419
                self.set_revision_history(source.revision_history())
 
1420
            result.new_revno, result.new_revid = self.last_revision_info()
 
1421
            if _hook_master:
 
1422
                result.master_branch = _hook_master
 
1423
                result.local_branch = self
 
1424
            else:
 
1425
                result.master_branch = self
 
1426
                result.local_branch = None
 
1427
            if _run_hooks:
 
1428
                for hook in Branch.hooks['post_pull']:
 
1429
                    hook(result)
 
1430
        finally:
 
1431
            source.unlock()
 
1432
        return result
 
1433
 
 
1434
    def _get_parent_location(self):
 
1435
        _locs = ['parent', 'pull', 'x-pull']
 
1436
        for l in _locs:
 
1437
            try:
 
1438
                return self.control_files.get(l).read().strip('\n')
 
1439
            except NoSuchFile:
 
1440
                pass
 
1441
        return None
 
1442
 
 
1443
    @needs_read_lock
 
1444
    def push(self, target, overwrite=False, stop_revision=None,
 
1445
        _hook_master=None, _run_hooks=True):
 
1446
        """See Branch.push.
 
1447
        
 
1448
        :param _hook_master: Private parameter - set the branch to 
 
1449
            be supplied as the master to push hooks.
 
1450
        :param _run_hooks: Private parameter - allow disabling of
 
1451
            hooks, used when pushing to a master branch.
 
1452
        """
 
1453
        result = PushResult()
 
1454
        result.source_branch = self
 
1455
        result.target_branch = target
 
1456
        target.lock_write()
 
1457
        try:
 
1458
            result.old_revno, result.old_revid = target.last_revision_info()
 
1459
            try:
 
1460
                target.update_revisions(self, stop_revision)
 
1461
            except DivergedBranches:
 
1462
                if not overwrite:
 
1463
                    raise
 
1464
            if overwrite:
 
1465
                target.set_revision_history(self.revision_history())
 
1466
            result.new_revno, result.new_revid = target.last_revision_info()
 
1467
            if _hook_master:
 
1468
                result.master_branch = _hook_master
 
1469
                result.local_branch = target
 
1470
            else:
 
1471
                result.master_branch = target
 
1472
                result.local_branch = None
 
1473
            if _run_hooks:
 
1474
                for hook in Branch.hooks['post_push']:
 
1475
                    hook(result)
 
1476
        finally:
 
1477
            target.unlock()
 
1478
        return result
 
1479
 
 
1480
    def get_parent(self):
 
1481
        """See Branch.get_parent."""
 
1482
 
 
1483
        assert self.base[-1] == '/'
 
1484
        parent = self._get_parent_location()
 
1485
        if parent is None:
 
1486
            return parent
 
1487
        # This is an old-format absolute path to a local branch
 
1488
        # turn it into a url
 
1489
        if parent.startswith('/'):
 
1490
            parent = urlutils.local_path_to_url(parent.decode('utf8'))
 
1491
        try:
 
1492
            return urlutils.join(self.base[:-1], parent)
 
1493
        except errors.InvalidURLJoin, e:
 
1494
            raise errors.InaccessibleParent(parent, self.base)
 
1495
 
 
1496
    def get_push_location(self):
 
1497
        """See Branch.get_push_location."""
 
1498
        push_loc = self.get_config().get_user_option('push_location')
 
1499
        return push_loc
 
1500
 
 
1501
    def set_push_location(self, location):
 
1502
        """See Branch.set_push_location."""
 
1503
        self.get_config().set_user_option(
 
1504
            'push_location', location,
 
1505
            store=_mod_config.STORE_LOCATION_NORECURSE)
 
1506
 
 
1507
    @needs_write_lock
 
1508
    def set_parent(self, url):
 
1509
        """See Branch.set_parent."""
 
1510
        # TODO: Maybe delete old location files?
 
1511
        # URLs should never be unicode, even on the local fs,
 
1512
        # FIXUP this and get_parent in a future branch format bump:
 
1513
        # read and rewrite the file, and have the new format code read
 
1514
        # using .get not .get_utf8. RBC 20060125
 
1515
        if url is not None:
 
1516
            if isinstance(url, unicode):
 
1517
                try: 
 
1518
                    url = url.encode('ascii')
 
1519
                except UnicodeEncodeError:
 
1520
                    raise bzrlib.errors.InvalidURL(url,
 
1521
                        "Urls must be 7-bit ascii, "
 
1522
                        "use bzrlib.urlutils.escape")
 
1523
            url = urlutils.relative_url(self.base, url)
 
1524
        self._set_parent_location(url)
 
1525
 
 
1526
    def _set_parent_location(self, url):
 
1527
        if url is None:
 
1528
            self.control_files._transport.delete('parent')
 
1529
        else:
 
1530
            assert isinstance(url, str)
 
1531
            self.control_files.put_bytes('parent', url + '\n')
 
1532
 
 
1533
    @deprecated_function(zero_nine)
 
1534
    def tree_config(self):
 
1535
        """DEPRECATED; call get_config instead.  
 
1536
        TreeConfig has become part of BranchConfig."""
 
1537
        return TreeConfig(self)
 
1538
 
 
1539
 
 
1540
class BzrBranch5(BzrBranch):
 
1541
    """A format 5 branch. This supports new features over plan branches.
 
1542
 
 
1543
    It has support for a master_branch which is the data for bound branches.
 
1544
    """
 
1545
 
 
1546
    def __init__(self,
 
1547
                 _format,
 
1548
                 _control_files,
 
1549
                 a_bzrdir,
 
1550
                 _repository):
 
1551
        super(BzrBranch5, self).__init__(_format=_format,
 
1552
                                         _control_files=_control_files,
 
1553
                                         a_bzrdir=a_bzrdir,
 
1554
                                         _repository=_repository)
 
1555
        
 
1556
    @needs_write_lock
 
1557
    def pull(self, source, overwrite=False, stop_revision=None,
 
1558
        _run_hooks=True):
 
1559
        """Extends branch.pull to be bound branch aware.
 
1560
        
 
1561
        :param _run_hooks: Private parameter used to force hook running
 
1562
            off during bound branch double-pushing.
 
1563
        """
 
1564
        bound_location = self.get_bound_location()
 
1565
        master_branch = None
 
1566
        if bound_location and source.base != bound_location:
 
1567
            # not pulling from master, so we need to update master.
 
1568
            master_branch = self.get_master_branch()
 
1569
            master_branch.lock_write()
 
1570
        try:
 
1571
            if master_branch:
 
1572
                # pull from source into master.
 
1573
                master_branch.pull(source, overwrite, stop_revision,
 
1574
                    _run_hooks=False)
 
1575
            return super(BzrBranch5, self).pull(source, overwrite,
 
1576
                stop_revision, _hook_master=master_branch,
 
1577
                _run_hooks=_run_hooks)
 
1578
        finally:
 
1579
            if master_branch:
 
1580
                master_branch.unlock()
 
1581
 
 
1582
    @needs_read_lock
 
1583
    def push(self, target, overwrite=False, stop_revision=None):
 
1584
        """Updates branch.push to be bound branch aware."""
 
1585
        bound_location = target.get_bound_location()
 
1586
        master_branch = None
 
1587
        if bound_location and target.base != bound_location:
 
1588
            # not pushing to master, so we need to update master.
 
1589
            master_branch = target.get_master_branch()
 
1590
            master_branch.lock_write()
 
1591
        try:
 
1592
            if master_branch:
 
1593
                # push into the master from this branch.
 
1594
                super(BzrBranch5, self).push(master_branch, overwrite,
 
1595
                    stop_revision, _run_hooks=False)
 
1596
            # and push into the target branch from this. Note that we push from
 
1597
            # this branch again, because its considered the highest bandwidth
 
1598
            # repository.
 
1599
            return super(BzrBranch5, self).push(target, overwrite,
 
1600
                stop_revision, _hook_master=master_branch)
 
1601
        finally:
 
1602
            if master_branch:
 
1603
                master_branch.unlock()
 
1604
 
 
1605
    def get_bound_location(self):
 
1606
        try:
 
1607
            return self.control_files.get_utf8('bound').read()[:-1]
 
1608
        except errors.NoSuchFile:
 
1609
            return None
 
1610
 
 
1611
    @needs_read_lock
 
1612
    def get_master_branch(self):
 
1613
        """Return the branch we are bound to.
 
1614
        
 
1615
        :return: Either a Branch, or None
 
1616
 
 
1617
        This could memoise the branch, but if thats done
 
1618
        it must be revalidated on each new lock.
 
1619
        So for now we just don't memoise it.
 
1620
        # RBC 20060304 review this decision.
 
1621
        """
 
1622
        bound_loc = self.get_bound_location()
 
1623
        if not bound_loc:
 
1624
            return None
 
1625
        try:
 
1626
            return Branch.open(bound_loc)
 
1627
        except (errors.NotBranchError, errors.ConnectionError), e:
 
1628
            raise errors.BoundBranchConnectionFailure(
 
1629
                    self, bound_loc, e)
 
1630
 
 
1631
    @needs_write_lock
 
1632
    def set_bound_location(self, location):
 
1633
        """Set the target where this branch is bound to.
 
1634
 
 
1635
        :param location: URL to the target branch
 
1636
        """
 
1637
        if location:
 
1638
            self.control_files.put_utf8('bound', location+'\n')
 
1639
        else:
 
1640
            try:
 
1641
                self.control_files._transport.delete('bound')
 
1642
            except NoSuchFile:
 
1643
                return False
 
1644
            return True
 
1645
 
 
1646
    @needs_write_lock
 
1647
    def bind(self, other):
 
1648
        """Bind this branch to the branch other.
 
1649
 
 
1650
        This does not push or pull data between the branches, though it does
 
1651
        check for divergence to raise an error when the branches are not
 
1652
        either the same, or one a prefix of the other. That behaviour may not
 
1653
        be useful, so that check may be removed in future.
 
1654
        
 
1655
        :param other: The branch to bind to
 
1656
        :type other: Branch
 
1657
        """
 
1658
        # TODO: jam 20051230 Consider checking if the target is bound
 
1659
        #       It is debatable whether you should be able to bind to
 
1660
        #       a branch which is itself bound.
 
1661
        #       Committing is obviously forbidden,
 
1662
        #       but binding itself may not be.
 
1663
        #       Since we *have* to check at commit time, we don't
 
1664
        #       *need* to check here
 
1665
 
 
1666
        # we want to raise diverged if:
 
1667
        # last_rev is not in the other_last_rev history, AND
 
1668
        # other_last_rev is not in our history, and do it without pulling
 
1669
        # history around
 
1670
        last_rev = self.last_revision()
 
1671
        if last_rev is not None:
 
1672
            other.lock_read()
 
1673
            try:
 
1674
                other_last_rev = other.last_revision()
 
1675
                if other_last_rev is not None:
 
1676
                    # neither branch is new, we have to do some work to
 
1677
                    # ascertain diversion.
 
1678
                    remote_graph = other.repository.get_revision_graph(
 
1679
                        other_last_rev)
 
1680
                    local_graph = self.repository.get_revision_graph(last_rev)
 
1681
                    if (last_rev not in remote_graph and
 
1682
                        other_last_rev not in local_graph):
 
1683
                        raise errors.DivergedBranches(self, other)
 
1684
            finally:
 
1685
                other.unlock()
 
1686
        self.set_bound_location(other.base)
 
1687
 
 
1688
    @needs_write_lock
 
1689
    def unbind(self):
 
1690
        """If bound, unbind"""
 
1691
        return self.set_bound_location(None)
 
1692
 
 
1693
    @needs_write_lock
 
1694
    def update(self):
 
1695
        """Synchronise this branch with the master branch if any. 
 
1696
 
 
1697
        :return: None or the last_revision that was pivoted out during the
 
1698
                 update.
 
1699
        """
 
1700
        master = self.get_master_branch()
 
1701
        if master is not None:
 
1702
            old_tip = self.last_revision()
 
1703
            self.pull(master, overwrite=True)
 
1704
            if old_tip in self.repository.get_ancestry(self.last_revision()):
 
1705
                return None
 
1706
            return old_tip
 
1707
        return None
 
1708
 
 
1709
 
 
1710
class BzrBranch6(BzrBranch5):
 
1711
 
 
1712
    @needs_read_lock
 
1713
    def last_revision_info(self):
 
1714
        revision_string = self.control_files.get('last-revision').read()
 
1715
        revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
 
1716
        revision_id = cache_utf8.get_cached_utf8(revision_id)
 
1717
        revno = int(revno)
 
1718
        return revno, revision_id
 
1719
 
 
1720
    def last_revision(self):
 
1721
        """Return last revision id, or None"""
 
1722
        revision_id = self.last_revision_info()[1]
 
1723
        if revision_id == _mod_revision.NULL_REVISION:
 
1724
            revision_id = None
 
1725
        return revision_id
 
1726
 
 
1727
    def _write_last_revision_info(self, revno, revision_id):
 
1728
        """Simply write out the revision id, with no checks.
 
1729
 
 
1730
        Use set_last_revision_info to perform this safely.
 
1731
 
 
1732
        Does not update the revision_history cache.
 
1733
        Intended to be called by set_last_revision_info and
 
1734
        _write_revision_history.
 
1735
        """
 
1736
        if revision_id is None:
 
1737
            revision_id = 'null:'
 
1738
        out_string = '%d %s\n' % (revno, revision_id)
 
1739
        self.control_files.put_bytes('last-revision', out_string)
 
1740
 
 
1741
    @needs_write_lock
 
1742
    def set_last_revision_info(self, revno, revision_id):
 
1743
        revision_id = osutils.safe_revision_id(revision_id)
 
1744
        if self._get_append_revisions_only():
 
1745
            self._check_history_violation(revision_id)
 
1746
        self._write_last_revision_info(revno, revision_id)
 
1747
        transaction = self.get_transaction()
 
1748
        cached_history = transaction.map.find_revision_history()
 
1749
        if cached_history is not None:
 
1750
            transaction.map.remove_object(cached_history)
 
1751
 
 
1752
    def _check_history_violation(self, revision_id):
 
1753
        last_revision = self.last_revision()
 
1754
        if last_revision is None:
 
1755
            return
 
1756
        if last_revision not in self._lefthand_history(revision_id):
 
1757
            raise errors.AppendRevisionsOnlyViolation(self.base)
 
1758
 
 
1759
    def _gen_revision_history(self):
 
1760
        """Generate the revision history from last revision
 
1761
        """
 
1762
        history = list(self.repository.iter_reverse_revision_history(
 
1763
            self.last_revision()))
 
1764
        history.reverse()
 
1765
        return history
 
1766
 
 
1767
    def _write_revision_history(self, history):
 
1768
        """Factored out of set_revision_history.
 
1769
 
 
1770
        This performs the actual writing to disk, with format-specific checks.
 
1771
        It is intended to be called by BzrBranch5.set_revision_history.
 
1772
        """
 
1773
        if len(history) == 0:
 
1774
            last_revision = 'null:'
 
1775
        else:
 
1776
            if history != self._lefthand_history(history[-1]):
 
1777
                raise errors.NotLefthandHistory(history)
 
1778
            last_revision = history[-1]
 
1779
        if self._get_append_revisions_only():
 
1780
            self._check_history_violation(last_revision)
 
1781
        self._write_last_revision_info(len(history), last_revision)
 
1782
 
 
1783
    @needs_write_lock
 
1784
    def append_revision(self, *revision_ids):
 
1785
        revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
 
1786
        if len(revision_ids) == 0:
 
1787
            return
 
1788
        prev_revno, prev_revision = self.last_revision_info()
 
1789
        for revision in self.repository.get_revisions(revision_ids):
 
1790
            if prev_revision == _mod_revision.NULL_REVISION:
 
1791
                if revision.parent_ids != []:
 
1792
                    raise errors.NotLeftParentDescendant(self, prev_revision,
 
1793
                                                         revision.revision_id)
 
1794
            else:
 
1795
                if revision.parent_ids[0] != prev_revision:
 
1796
                    raise errors.NotLeftParentDescendant(self, prev_revision,
 
1797
                                                         revision.revision_id)
 
1798
            prev_revision = revision.revision_id
 
1799
        self.set_last_revision_info(prev_revno + len(revision_ids),
 
1800
                                    revision_ids[-1])
 
1801
 
 
1802
    def _set_config_location(self, name, url, config=None,
 
1803
                             make_relative=False):
 
1804
        if config is None:
 
1805
            config = self.get_config()
 
1806
        if url is None:
 
1807
            url = ''
 
1808
        elif make_relative:
 
1809
            url = urlutils.relative_url(self.base, url)
 
1810
        config.set_user_option(name, url)
 
1811
 
 
1812
 
 
1813
    def _get_config_location(self, name, config=None):
 
1814
        if config is None:
 
1815
            config = self.get_config()
 
1816
        location = config.get_user_option(name)
 
1817
        if location == '':
 
1818
            location = None
 
1819
        return location
 
1820
 
 
1821
    @needs_write_lock
 
1822
    def _set_parent_location(self, url):
 
1823
        """Set the parent branch"""
 
1824
        self._set_config_location('parent_location', url, make_relative=True)
 
1825
 
 
1826
    @needs_read_lock
 
1827
    def _get_parent_location(self):
 
1828
        """Set the parent branch"""
 
1829
        return self._get_config_location('parent_location')
 
1830
 
 
1831
    def set_push_location(self, location):
 
1832
        """See Branch.set_push_location."""
 
1833
        self._set_config_location('push_location', location)
 
1834
 
 
1835
    def set_bound_location(self, location):
 
1836
        """See Branch.set_push_location."""
 
1837
        result = None
 
1838
        config = self.get_config()
 
1839
        if location is None:
 
1840
            if config.get_user_option('bound') != 'True':
 
1841
                return False
 
1842
            else:
 
1843
                config.set_user_option('bound', 'False')
 
1844
                return True
 
1845
        else:
 
1846
            self._set_config_location('bound_location', location,
 
1847
                                      config=config)
 
1848
            config.set_user_option('bound', 'True')
 
1849
        return True
 
1850
 
 
1851
    def _get_bound_location(self, bound):
 
1852
        """Return the bound location in the config file.
 
1853
 
 
1854
        Return None if the bound parameter does not match"""
 
1855
        config = self.get_config()
 
1856
        config_bound = (config.get_user_option('bound') == 'True')
 
1857
        if config_bound != bound:
 
1858
            return None
 
1859
        return self._get_config_location('bound_location', config=config)
 
1860
 
 
1861
    def get_bound_location(self):
 
1862
        """See Branch.set_push_location."""
 
1863
        return self._get_bound_location(True)
 
1864
 
 
1865
    def get_old_bound_location(self):
 
1866
        """See Branch.get_old_bound_location"""
 
1867
        return self._get_bound_location(False)
 
1868
 
 
1869
    def set_append_revisions_only(self, enabled):
 
1870
        if enabled:
 
1871
            value = 'True'
 
1872
        else:
 
1873
            value = 'False'
 
1874
        self.get_config().set_user_option('append_revisions_only', value)
 
1875
 
 
1876
    def _get_append_revisions_only(self):
 
1877
        value = self.get_config().get_user_option('append_revisions_only')
 
1878
        return value == 'True'
 
1879
 
 
1880
    def _synchronize_history(self, destination, revision_id):
 
1881
        """Synchronize last revision and revision history between branches.
 
1882
 
 
1883
        This version is most efficient when the destination is also a
 
1884
        BzrBranch6, but works for BzrBranch5, as long as the destination's
 
1885
        repository contains all the lefthand ancestors of the intended
 
1886
        last_revision.  If not, set_last_revision_info will fail.
 
1887
 
 
1888
        :param destination: The branch to copy the history into
 
1889
        :param revision_id: The revision-id to truncate history at.  May
 
1890
          be None to copy complete history.
 
1891
        """
 
1892
        if revision_id is None:
 
1893
            revno, revision_id = self.last_revision_info()
 
1894
        else:
 
1895
            revno = self.revision_id_to_revno(revision_id)
 
1896
        destination.set_last_revision_info(revno, revision_id)
 
1897
 
 
1898
 
 
1899
class BranchTestProviderAdapter(object):
 
1900
    """A tool to generate a suite testing multiple branch formats at once.
 
1901
 
 
1902
    This is done by copying the test once for each transport and injecting
 
1903
    the transport_server, transport_readonly_server, and branch_format
 
1904
    classes into each copy. Each copy is also given a new id() to make it
 
1905
    easy to identify.
 
1906
    """
 
1907
 
 
1908
    def __init__(self, transport_server, transport_readonly_server, formats):
 
1909
        self._transport_server = transport_server
 
1910
        self._transport_readonly_server = transport_readonly_server
 
1911
        self._formats = formats
 
1912
    
 
1913
    def adapt(self, test):
 
1914
        result = TestSuite()
 
1915
        for branch_format, bzrdir_format in self._formats:
 
1916
            new_test = deepcopy(test)
 
1917
            new_test.transport_server = self._transport_server
 
1918
            new_test.transport_readonly_server = self._transport_readonly_server
 
1919
            new_test.bzrdir_format = bzrdir_format
 
1920
            new_test.branch_format = branch_format
 
1921
            def make_new_test_id():
 
1922
                new_id = "%s(%s)" % (new_test.id(), branch_format.__class__.__name__)
 
1923
                return lambda: new_id
 
1924
            new_test.id = make_new_test_id()
 
1925
            result.addTest(new_test)
 
1926
        return result
 
1927
 
 
1928
 
 
1929
######################################################################
 
1930
# results of operations
 
1931
 
 
1932
class PullResult(object):
 
1933
    """Result of a Branch.pull operation.
 
1934
 
 
1935
    :ivar old_revno: Revision number before pull.
 
1936
    :ivar new_revno: Revision number after pull.
 
1937
    :ivar old_revid: Tip revision id before pull.
 
1938
    :ivar new_revid: Tip revision id after pull.
 
1939
    :ivar source_branch: Source (local) branch object.
 
1940
    :ivar master_branch: Master branch of the target, or None.
 
1941
    :ivar target_branch: Target/destination branch object.
 
1942
    """
 
1943
 
 
1944
    def __int__(self):
 
1945
        # DEPRECATED: pull used to return the change in revno
 
1946
        return self.new_revno - self.old_revno
 
1947
 
 
1948
 
 
1949
class PushResult(object):
 
1950
    """Result of a Branch.push operation.
 
1951
 
 
1952
    :ivar old_revno: Revision number before push.
 
1953
    :ivar new_revno: Revision number after push.
 
1954
    :ivar old_revid: Tip revision id before push.
 
1955
    :ivar new_revid: Tip revision id after push.
 
1956
    :ivar source_branch: Source branch object.
 
1957
    :ivar master_branch: Master branch of the target, or None.
 
1958
    :ivar target_branch: Target/destination branch object.
 
1959
    """
 
1960
 
 
1961
    def __int__(self):
 
1962
        # DEPRECATED: push used to return the change in revno
 
1963
        return self.new_revno - self.old_revno
 
1964
 
 
1965
 
 
1966
class BranchCheckResult(object):
 
1967
    """Results of checking branch consistency.
 
1968
 
 
1969
    :see: Branch.check
 
1970
    """
 
1971
 
 
1972
    def __init__(self, branch):
 
1973
        self.branch = branch
 
1974
 
 
1975
    def report_results(self, verbose):
 
1976
        """Report the check results via trace.note.
 
1977
        
 
1978
        :param verbose: Requests more detailed display of what was checked,
 
1979
            if any.
 
1980
        """
 
1981
        note('checked branch %s format %s',
 
1982
             self.branch.base,
 
1983
             self.branch._format)
 
1984
 
 
1985
 
 
1986
class Converter5to6(object):
 
1987
    """Perform an in-place upgrade of format 5 to format 6"""
 
1988
 
 
1989
    def convert(self, branch):
 
1990
        # Data for 5 and 6 can peacefully coexist.
 
1991
        format = BzrBranchFormat6()
 
1992
        new_branch = format.open(branch.bzrdir, _found=True)
 
1993
 
 
1994
        # Copy source data into target
 
1995
        new_branch.set_last_revision_info(*branch.last_revision_info())
 
1996
        new_branch.set_parent(branch.get_parent())
 
1997
        new_branch.set_bound_location(branch.get_bound_location())
 
1998
        new_branch.set_push_location(branch.get_push_location())
 
1999
 
 
2000
        # Copying done; now update target format
 
2001
        new_branch.control_files.put_utf8('format',
 
2002
            format.get_format_string())
 
2003
 
 
2004
        # Clean up old files
 
2005
        new_branch.control_files._transport.delete('revision-history')
 
2006
        try:
 
2007
            branch.set_parent(None)
 
2008
        except NoSuchFile:
 
2009
            pass
 
2010
        branch.set_bound_location(None)