1
# Copyright (C) 2005, 2006 Canonical Ltd
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.
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.
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
18
from copy import deepcopy
19
from cStringIO import StringIO
24
from unittest import TestSuite
25
from warnings import warn
28
import bzrlib.bzrdir as bzrdir
29
from bzrlib.config import TreeConfig
30
from bzrlib.decorators import needs_read_lock, needs_write_lock
31
from bzrlib.delta import compare_trees
32
import bzrlib.errors as errors
33
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
34
NoSuchRevision, HistoryMissing, NotBranchError,
35
DivergedBranches, LockError,
36
UninitializableFormat,
38
UnlistableBranch, NoSuchFile, NotVersionedError,
40
import bzrlib.inventory as inventory
41
from bzrlib.inventory import Inventory
42
from bzrlib.lockable_files import LockableFiles, TransportLock
43
from bzrlib.lockdir import LockDir
44
from bzrlib.osutils import (isdir, quotefn,
45
rename, splitpath, sha_file,
46
file_kind, abspath, normpath, pathjoin,
50
from bzrlib.repository import Repository
51
from bzrlib.revision import (
56
from bzrlib.store import copy_all
57
from bzrlib.symbol_versioning import *
58
from bzrlib.textui import show_status
59
from bzrlib.trace import mutter, note
60
import bzrlib.transactions as transactions
61
from bzrlib.transport import Transport, get_transport
62
from bzrlib.tree import EmptyTree, RevisionTree
64
import bzrlib.urlutils as urlutils
68
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
69
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
70
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
73
# TODO: Maybe include checks for common corruption of newlines, etc?
75
# TODO: Some operations like log might retrieve the same revisions
76
# repeatedly to calculate deltas. We could perhaps have a weakref
77
# cache in memory to make this faster. In general anything can be
78
# cached in memory between lock and unlock operations. .. nb thats
79
# what the transaction identity map provides
82
######################################################################
86
"""Branch holding a history of revisions.
89
Base directory/url of the branch.
91
# this is really an instance variable - FIXME move it there
95
def __init__(self, *ignored, **ignored_too):
96
raise NotImplementedError('The Branch class is abstract')
99
"""Break a lock if one is present from another instance.
101
Uses the ui factory to ask for confirmation if the lock may be from
104
This will probe the repository for its lock as well.
106
self.control_files.break_lock()
107
self.repository.break_lock()
108
master = self.get_master_branch()
109
if master is not None:
113
@deprecated_method(zero_eight)
114
def open_downlevel(base):
115
"""Open a branch which may be of an old format."""
116
return Branch.open(base, _unsupported=True)
119
def open(base, _unsupported=False):
120
"""Open the repository rooted at base.
122
For instance, if the repository is at URL/.bzr/repository,
123
Repository.open(URL) -> a Repository instance.
125
control = bzrdir.BzrDir.open(base, _unsupported)
126
return control.open_branch(_unsupported)
129
def open_containing(url):
130
"""Open an existing branch which contains url.
132
This probes for a branch at url, and searches upwards from there.
134
Basically we keep looking up until we find the control directory or
135
run into the root. If there isn't one, raises NotBranchError.
136
If there is one and it is either an unrecognised format or an unsupported
137
format, UnknownFormatError or UnsupportedFormatError are raised.
138
If there is one, it is returned, along with the unused portion of url.
140
control, relpath = bzrdir.BzrDir.open_containing(url)
141
return control.open_branch(), relpath
144
@deprecated_function(zero_eight)
145
def initialize(base):
146
"""Create a new working tree and branch, rooted at 'base' (url)
148
NOTE: This will soon be deprecated in favour of creation
151
return bzrdir.BzrDir.create_standalone_workingtree(base).branch
153
def setup_caching(self, cache_root):
154
"""Subclasses that care about caching should override this, and set
155
up cached stores located under cache_root.
157
# seems to be unused, 2006-01-13 mbp
158
warn('%s is deprecated' % self.setup_caching)
159
self.cache_root = cache_root
162
cfg = self.tree_config()
163
return cfg.get_option(u"nickname", default=self.base.split('/')[-2])
165
def _set_nick(self, nick):
166
cfg = self.tree_config()
167
cfg.set_option(nick, "nickname")
168
assert cfg.get_option("nickname") == nick
170
nick = property(_get_nick, _set_nick)
173
raise NotImplementedError('is_locked is abstract')
175
def lock_write(self):
176
raise NotImplementedError('lock_write is abstract')
179
raise NotImplementedError('lock_read is abstract')
182
raise NotImplementedError('unlock is abstract')
184
def peek_lock_mode(self):
185
"""Return lock mode for the Branch: 'r', 'w' or None"""
186
raise NotImplementedError(self.peek_lock_mode)
188
def get_physical_lock_status(self):
189
raise NotImplementedError('get_physical_lock_status is abstract')
191
def abspath(self, name):
192
"""Return absolute filename for something in the branch
194
XXX: Robert Collins 20051017 what is this used for? why is it a branch
195
method and not a tree method.
197
raise NotImplementedError('abspath is abstract')
199
def bind(self, other):
200
"""Bind the local branch the other branch.
202
:param other: The branch to bind to
205
raise errors.UpgradeRequired(self.base)
208
def fetch(self, from_branch, last_revision=None, pb=None):
209
"""Copy revisions from from_branch into this branch.
211
:param from_branch: Where to copy from.
212
:param last_revision: What revision to stop at (None for at the end
214
:param pb: An optional progress bar to use.
216
Returns the copied revision count and the failed revisions in a tuple:
219
if self.base == from_branch.base:
222
nested_pb = bzrlib.ui.ui_factory.nested_progress_bar()
227
from_branch.lock_read()
229
if last_revision is None:
230
pb.update('get source history')
231
from_history = from_branch.revision_history()
233
last_revision = from_history[-1]
235
# no history in the source branch
236
last_revision = NULL_REVISION
237
return self.repository.fetch(from_branch.repository,
238
revision_id=last_revision,
241
if nested_pb is not None:
245
def get_bound_location(self):
246
"""Return the URL of the branch we are bound to.
248
Older format branches cannot bind, please be sure to use a metadir
253
def get_master_branch(self):
254
"""Return the branch we are bound to.
256
:return: Either a Branch, or None
260
def get_root_id(self):
261
"""Return the id of this branches root"""
262
raise NotImplementedError('get_root_id is abstract')
264
def print_file(self, file, revision_id):
265
"""Print `file` to stdout."""
266
raise NotImplementedError('print_file is abstract')
268
def append_revision(self, *revision_ids):
269
raise NotImplementedError('append_revision is abstract')
271
def set_revision_history(self, rev_history):
272
raise NotImplementedError('set_revision_history is abstract')
274
def revision_history(self):
275
"""Return sequence of revision hashes on to this branch."""
276
raise NotImplementedError('revision_history is abstract')
279
"""Return current revision number for this branch.
281
That is equivalent to the number of revisions committed to
284
return len(self.revision_history())
287
"""Older format branches cannot bind or unbind."""
288
raise errors.UpgradeRequired(self.base)
290
def last_revision(self):
291
"""Return last patch hash, or None if no history."""
292
ph = self.revision_history()
298
def missing_revisions(self, other, stop_revision=None):
299
"""Return a list of new revisions that would perfectly fit.
301
If self and other have not diverged, return a list of the revisions
302
present in other, but missing from self.
304
>>> from bzrlib.workingtree import WorkingTree
305
>>> bzrlib.trace.silent = True
306
>>> d1 = bzrdir.ScratchDir()
307
>>> br1 = d1.open_branch()
308
>>> wt1 = d1.open_workingtree()
309
>>> d2 = bzrdir.ScratchDir()
310
>>> br2 = d2.open_branch()
311
>>> wt2 = d2.open_workingtree()
312
>>> br1.missing_revisions(br2)
314
>>> wt2.commit("lala!", rev_id="REVISION-ID-1")
315
>>> br1.missing_revisions(br2)
317
>>> br2.missing_revisions(br1)
319
>>> wt1.commit("lala!", rev_id="REVISION-ID-1")
320
>>> br1.missing_revisions(br2)
322
>>> wt2.commit("lala!", rev_id="REVISION-ID-2A")
323
>>> br1.missing_revisions(br2)
325
>>> wt1.commit("lala!", rev_id="REVISION-ID-2B")
326
>>> br1.missing_revisions(br2)
327
Traceback (most recent call last):
328
DivergedBranches: These branches have diverged. Try merge.
330
self_history = self.revision_history()
331
self_len = len(self_history)
332
other_history = other.revision_history()
333
other_len = len(other_history)
334
common_index = min(self_len, other_len) -1
335
if common_index >= 0 and \
336
self_history[common_index] != other_history[common_index]:
337
raise DivergedBranches(self, other)
339
if stop_revision is None:
340
stop_revision = other_len
342
assert isinstance(stop_revision, int)
343
if stop_revision > other_len:
344
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
345
return other_history[self_len:stop_revision]
347
def update_revisions(self, other, stop_revision=None):
348
"""Pull in new perfect-fit revisions.
350
:param other: Another Branch to pull from
351
:param stop_revision: Updated until the given revision
354
raise NotImplementedError('update_revisions is abstract')
356
def revision_id_to_revno(self, revision_id):
357
"""Given a revision id, return its revno"""
358
if revision_id is None:
360
history = self.revision_history()
362
return history.index(revision_id) + 1
364
raise bzrlib.errors.NoSuchRevision(self, revision_id)
366
def get_rev_id(self, revno, history=None):
367
"""Find the revision id of the specified revno."""
371
history = self.revision_history()
372
elif revno <= 0 or revno > len(history):
373
raise bzrlib.errors.NoSuchRevision(self, revno)
374
return history[revno - 1]
376
def pull(self, source, overwrite=False, stop_revision=None):
377
raise NotImplementedError('pull is abstract')
379
def basis_tree(self):
380
"""Return `Tree` object for last revision.
382
If there are no revisions yet, return an `EmptyTree`.
384
return self.repository.revision_tree(self.last_revision())
386
def rename_one(self, from_rel, to_rel):
389
This can change the directory or the filename or both.
391
raise NotImplementedError('rename_one is abstract')
393
def move(self, from_paths, to_name):
396
to_name must exist as a versioned directory.
398
If to_name exists and is a directory, the files are moved into
399
it, keeping their old names. If it is a directory,
401
Note that to_name is only the last component of the new name;
402
this doesn't change the directory.
404
This returns a list of (from_path, to_path) pairs for each
407
raise NotImplementedError('move is abstract')
409
def get_parent(self):
410
"""Return the parent location of the branch.
412
This is the default location for push/pull/missing. The usual
413
pattern is that the user can override it by specifying a
416
raise NotImplementedError('get_parent is abstract')
418
def get_push_location(self):
419
"""Return the None or the location to push this branch to."""
420
raise NotImplementedError('get_push_location is abstract')
422
def set_push_location(self, location):
423
"""Set a new push location for this branch."""
424
raise NotImplementedError('set_push_location is abstract')
426
def set_parent(self, url):
427
raise NotImplementedError('set_parent is abstract')
431
"""Synchronise this branch with the master branch if any.
433
:return: None or the last_revision pivoted out during the update.
437
def check_revno(self, revno):
439
Check whether a revno corresponds to any revision.
440
Zero (the NULL revision) is considered valid.
443
self.check_real_revno(revno)
445
def check_real_revno(self, revno):
447
Check whether a revno corresponds to a real revision.
448
Zero (the NULL revision) is considered invalid
450
if revno < 1 or revno > self.revno():
451
raise InvalidRevisionNumber(revno)
454
def clone(self, *args, **kwargs):
455
"""Clone this branch into to_bzrdir preserving all semantic values.
457
revision_id: if not None, the revision history in the new branch will
458
be truncated to end with revision_id.
460
# for API compatability, until 0.8 releases we provide the old api:
461
# def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
462
# after 0.8 releases, the *args and **kwargs should be changed:
463
# def clone(self, to_bzrdir, revision_id=None):
464
if (kwargs.get('to_location', None) or
465
kwargs.get('revision', None) or
466
kwargs.get('basis_branch', None) or
467
(len(args) and isinstance(args[0], basestring))):
468
# backwards compatability api:
469
warn("Branch.clone() has been deprecated for BzrDir.clone() from"
470
" bzrlib 0.8.", DeprecationWarning, stacklevel=3)
473
basis_branch = args[2]
475
basis_branch = kwargs.get('basis_branch', None)
477
basis = basis_branch.bzrdir
482
revision_id = args[1]
484
revision_id = kwargs.get('revision', None)
489
# no default to raise if not provided.
490
url = kwargs.get('to_location')
491
return self.bzrdir.clone(url,
492
revision_id=revision_id,
493
basis=basis).open_branch()
495
# generate args by hand
497
revision_id = args[1]
499
revision_id = kwargs.get('revision_id', None)
503
# no default to raise if not provided.
504
to_bzrdir = kwargs.get('to_bzrdir')
505
result = self._format.initialize(to_bzrdir)
506
self.copy_content_into(result, revision_id=revision_id)
510
def sprout(self, to_bzrdir, revision_id=None):
511
"""Create a new line of development from the branch, into to_bzrdir.
513
revision_id: if not None, the revision history in the new branch will
514
be truncated to end with revision_id.
516
result = self._format.initialize(to_bzrdir)
517
self.copy_content_into(result, revision_id=revision_id)
518
result.set_parent(self.bzrdir.root_transport.base)
522
def copy_content_into(self, destination, revision_id=None):
523
"""Copy the content of self into destination.
525
revision_id: if not None, the revision history in the new branch will
526
be truncated to end with revision_id.
528
new_history = self.revision_history()
529
if revision_id is not None:
531
new_history = new_history[:new_history.index(revision_id) + 1]
533
rev = self.repository.get_revision(revision_id)
534
new_history = rev.get_history(self.repository)[1:]
535
destination.set_revision_history(new_history)
536
parent = self.get_parent()
538
destination.set_parent(parent)
541
class BranchFormat(object):
542
"""An encapsulation of the initialization and open routines for a format.
544
Formats provide three things:
545
* An initialization routine,
549
Formats are placed in an dict by their format string for reference
550
during branch opening. Its not required that these be instances, they
551
can be classes themselves with class methods - it simply depends on
552
whether state is needed for a given format or not.
554
Once a format is deprecated, just deprecate the initialize and open
555
methods on the format class. Do not deprecate the object, as the
556
object will be created every time regardless.
559
_default_format = None
560
"""The default format used for new branches."""
563
"""The known formats."""
566
def find_format(klass, a_bzrdir):
567
"""Return the format for the branch object in a_bzrdir."""
569
transport = a_bzrdir.get_branch_transport(None)
570
format_string = transport.get("format").read()
571
return klass._formats[format_string]
573
raise NotBranchError(path=transport.base)
575
raise errors.UnknownFormatError(format_string)
578
def get_default_format(klass):
579
"""Return the current default format."""
580
return klass._default_format
582
def get_format_string(self):
583
"""Return the ASCII format string that identifies this format."""
584
raise NotImplementedError(self.get_format_string)
586
def get_format_description(self):
587
"""Return the short format description for this format."""
588
raise NotImplementedError(self.get_format_string)
590
def initialize(self, a_bzrdir):
591
"""Create a branch of this format in a_bzrdir."""
592
raise NotImplementedError(self.initialized)
594
def is_supported(self):
595
"""Is this format supported?
597
Supported formats can be initialized and opened.
598
Unsupported formats may not support initialization or committing or
599
some other features depending on the reason for not being supported.
603
def open(self, a_bzrdir, _found=False):
604
"""Return the branch object for a_bzrdir
606
_found is a private parameter, do not use it. It is used to indicate
607
if format probing has already be done.
609
raise NotImplementedError(self.open)
612
def register_format(klass, format):
613
klass._formats[format.get_format_string()] = format
616
def set_default_format(klass, format):
617
klass._default_format = format
620
def unregister_format(klass, format):
621
assert klass._formats[format.get_format_string()] is format
622
del klass._formats[format.get_format_string()]
625
return self.get_format_string().rstrip()
628
class BzrBranchFormat4(BranchFormat):
629
"""Bzr branch format 4.
632
- a revision-history file.
633
- a branch-lock lock file [ to be shared with the bzrdir ]
636
def get_format_description(self):
637
"""See BranchFormat.get_format_description()."""
638
return "Branch format 4"
640
def initialize(self, a_bzrdir):
641
"""Create a branch of this format in a_bzrdir."""
642
mutter('creating branch in %s', a_bzrdir.transport.base)
643
branch_transport = a_bzrdir.get_branch_transport(self)
644
utf8_files = [('revision-history', ''),
647
control_files = LockableFiles(branch_transport, 'branch-lock',
649
control_files.create_lock()
650
control_files.lock_write()
652
for file, content in utf8_files:
653
control_files.put_utf8(file, content)
655
control_files.unlock()
656
return self.open(a_bzrdir, _found=True)
659
super(BzrBranchFormat4, self).__init__()
660
self._matchingbzrdir = bzrdir.BzrDirFormat6()
662
def open(self, a_bzrdir, _found=False):
663
"""Return the branch object for a_bzrdir
665
_found is a private parameter, do not use it. It is used to indicate
666
if format probing has already be done.
669
# we are being called directly and must probe.
670
raise NotImplementedError
671
return BzrBranch(_format=self,
672
_control_files=a_bzrdir._control_files,
674
_repository=a_bzrdir.open_repository())
677
return "Bazaar-NG branch format 4"
680
class BzrBranchFormat5(BranchFormat):
681
"""Bzr branch format 5.
684
- a revision-history file.
686
- a lock dir guarding the branch itself
687
- all of this stored in a branch/ subdirectory
688
- works with shared repositories.
690
This format is new in bzr 0.8.
693
def get_format_string(self):
694
"""See BranchFormat.get_format_string()."""
695
return "Bazaar-NG branch format 5\n"
697
def get_format_description(self):
698
"""See BranchFormat.get_format_description()."""
699
return "Branch format 5"
701
def initialize(self, a_bzrdir):
702
"""Create a branch of this format in a_bzrdir."""
703
mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
704
branch_transport = a_bzrdir.get_branch_transport(self)
705
utf8_files = [('revision-history', ''),
708
control_files = LockableFiles(branch_transport, 'lock', LockDir)
709
control_files.create_lock()
710
control_files.lock_write()
711
control_files.put_utf8('format', self.get_format_string())
713
for file, content in utf8_files:
714
control_files.put_utf8(file, content)
716
control_files.unlock()
717
return self.open(a_bzrdir, _found=True, )
720
super(BzrBranchFormat5, self).__init__()
721
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
723
def open(self, a_bzrdir, _found=False):
724
"""Return the branch object for a_bzrdir
726
_found is a private parameter, do not use it. It is used to indicate
727
if format probing has already be done.
730
format = BranchFormat.find_format(a_bzrdir)
731
assert format.__class__ == self.__class__
732
transport = a_bzrdir.get_branch_transport(None)
733
control_files = LockableFiles(transport, 'lock', LockDir)
734
return BzrBranch5(_format=self,
735
_control_files=control_files,
737
_repository=a_bzrdir.find_repository())
740
return "Bazaar-NG Metadir branch format 5"
743
class BranchReferenceFormat(BranchFormat):
744
"""Bzr branch reference format.
746
Branch references are used in implementing checkouts, they
747
act as an alias to the real branch which is at some other url.
754
def get_format_string(self):
755
"""See BranchFormat.get_format_string()."""
756
return "Bazaar-NG Branch Reference Format 1\n"
758
def get_format_description(self):
759
"""See BranchFormat.get_format_description()."""
760
return "Checkout reference format 1"
762
def initialize(self, a_bzrdir, target_branch=None):
763
"""Create a branch of this format in a_bzrdir."""
764
if target_branch is None:
765
# this format does not implement branch itself, thus the implicit
766
# creation contract must see it as uninitializable
767
raise errors.UninitializableFormat(self)
768
mutter('creating branch reference in %s', a_bzrdir.transport.base)
769
branch_transport = a_bzrdir.get_branch_transport(self)
770
# FIXME rbc 20060209 one j-a-ms encoding branch lands this str() cast is not needed.
771
branch_transport.put('location', StringIO(str(target_branch.bzrdir.root_transport.base)))
772
branch_transport.put('format', StringIO(self.get_format_string()))
773
return self.open(a_bzrdir, _found=True)
776
super(BranchReferenceFormat, self).__init__()
777
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
779
def _make_reference_clone_function(format, a_branch):
780
"""Create a clone() routine for a branch dynamically."""
781
def clone(to_bzrdir, revision_id=None):
782
"""See Branch.clone()."""
783
return format.initialize(to_bzrdir, a_branch)
784
# cannot obey revision_id limits when cloning a reference ...
785
# FIXME RBC 20060210 either nuke revision_id for clone, or
786
# emit some sort of warning/error to the caller ?!
789
def open(self, a_bzrdir, _found=False):
790
"""Return the branch that the branch reference in a_bzrdir points at.
792
_found is a private parameter, do not use it. It is used to indicate
793
if format probing has already be done.
796
format = BranchFormat.find_format(a_bzrdir)
797
assert format.__class__ == self.__class__
798
transport = a_bzrdir.get_branch_transport(None)
799
real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
800
result = real_bzrdir.open_branch()
801
# this changes the behaviour of result.clone to create a new reference
802
# rather than a copy of the content of the branch.
803
# I did not use a proxy object because that needs much more extensive
804
# testing, and we are only changing one behaviour at the moment.
805
# If we decide to alter more behaviours - i.e. the implicit nickname
806
# then this should be refactored to introduce a tested proxy branch
807
# and a subclass of that for use in overriding clone() and ....
809
result.clone = self._make_reference_clone_function(result)
813
# formats which have no format string are not discoverable
814
# and not independently creatable, so are not registered.
815
__default_format = BzrBranchFormat5()
816
BranchFormat.register_format(__default_format)
817
BranchFormat.register_format(BranchReferenceFormat())
818
BranchFormat.set_default_format(__default_format)
819
_legacy_formats = [BzrBranchFormat4(),
822
class BzrBranch(Branch):
823
"""A branch stored in the actual filesystem.
825
Note that it's "local" in the context of the filesystem; it doesn't
826
really matter if it's on an nfs/smb/afs/coda/... share, as long as
827
it's writable, and can be accessed via the normal filesystem API.
830
def __init__(self, transport=DEPRECATED_PARAMETER, init=DEPRECATED_PARAMETER,
831
relax_version_check=DEPRECATED_PARAMETER, _format=None,
832
_control_files=None, a_bzrdir=None, _repository=None):
833
"""Create new branch object at a particular location.
835
transport -- A Transport object, defining how to access files.
837
init -- If True, create new control files in a previously
838
unversioned directory. If False, the branch must already
841
relax_version_check -- If true, the usual check for the branch
842
version is not applied. This is intended only for
843
upgrade/recovery type use; it's not guaranteed that
844
all operations will work on old format branches.
847
self.bzrdir = bzrdir.BzrDir.open(transport.base)
849
self.bzrdir = a_bzrdir
850
self._transport = self.bzrdir.transport.clone('..')
851
self._base = self._transport.base
852
self._format = _format
853
if _control_files is None:
854
raise BzrBadParameterMissing('_control_files')
855
self.control_files = _control_files
856
if deprecated_passed(init):
857
warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
858
"deprecated as of bzr 0.8. Please use Branch.create().",
862
# this is slower than before deprecation, oh well never mind.
864
self._initialize(transport.base)
865
self._check_format(_format)
866
if deprecated_passed(relax_version_check):
867
warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
868
"relax_version_check parameter is deprecated as of bzr 0.8. "
869
"Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
873
if (not relax_version_check
874
and not self._format.is_supported()):
875
raise errors.UnsupportedFormatError(
876
'sorry, branch format %r not supported' % fmt,
877
['use a different bzr version',
878
'or remove the .bzr directory'
879
' and "bzr init" again'])
880
if deprecated_passed(transport):
881
warn("BzrBranch.__init__(transport=XXX...): The transport "
882
"parameter is deprecated as of bzr 0.8. "
883
"Please use Branch.open, or bzrdir.open_branch().",
886
self.repository = _repository
889
return '%s(%r)' % (self.__class__.__name__, self.base)
894
# TODO: It might be best to do this somewhere else,
895
# but it is nice for a Branch object to automatically
896
# cache it's information.
897
# Alternatively, we could have the Transport objects cache requests
898
# See the earlier discussion about how major objects (like Branch)
899
# should never expect their __del__ function to run.
900
# XXX: cache_root seems to be unused, 2006-01-13 mbp
901
if hasattr(self, 'cache_root') and self.cache_root is not None:
903
rmtree(self.cache_root)
906
self.cache_root = None
911
base = property(_get_base, doc="The URL for the root of this branch.")
913
def _finish_transaction(self):
914
"""Exit the current transaction."""
915
return self.control_files._finish_transaction()
917
def get_transaction(self):
918
"""Return the current active transaction.
920
If no transaction is active, this returns a passthrough object
921
for which all data is immediately flushed and no caching happens.
923
# this is an explicit function so that we can do tricky stuff
924
# when the storage in rev_storage is elsewhere.
925
# we probably need to hook the two 'lock a location' and
926
# 'have a transaction' together more delicately, so that
927
# we can have two locks (branch and storage) and one transaction
928
# ... and finishing the transaction unlocks both, but unlocking
929
# does not. - RBC 20051121
930
return self.control_files.get_transaction()
932
def _set_transaction(self, transaction):
933
"""Set a new active transaction."""
934
return self.control_files._set_transaction(transaction)
936
def abspath(self, name):
937
"""See Branch.abspath."""
938
return self.control_files._transport.abspath(name)
940
def _check_format(self, format):
941
"""Identify the branch format if needed.
943
The format is stored as a reference to the format object in
944
self._format for code that needs to check it later.
946
The format parameter is either None or the branch format class
947
used to open this branch.
949
FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
952
format = BzrBranchFormat.find_format(self.bzrdir)
953
self._format = format
954
mutter("got branch format %s", self._format)
957
def get_root_id(self):
958
"""See Branch.get_root_id."""
959
tree = self.repository.revision_tree(self.last_revision())
960
return tree.inventory.root.file_id
963
return self.control_files.is_locked()
965
def lock_write(self):
966
# TODO: test for failed two phase locks. This is known broken.
967
self.control_files.lock_write()
968
self.repository.lock_write()
971
# TODO: test for failed two phase locks. This is known broken.
972
self.control_files.lock_read()
973
self.repository.lock_read()
976
# TODO: test for failed two phase locks. This is known broken.
978
self.repository.unlock()
980
self.control_files.unlock()
982
def peek_lock_mode(self):
983
if self.control_files._lock_count == 0:
986
return self.control_files._lock_mode
988
def get_physical_lock_status(self):
989
return self.control_files.get_physical_lock_status()
992
def print_file(self, file, revision_id):
993
"""See Branch.print_file."""
994
return self.repository.print_file(file, revision_id)
997
def append_revision(self, *revision_ids):
998
"""See Branch.append_revision."""
999
for revision_id in revision_ids:
1000
mutter("add {%s} to revision-history" % revision_id)
1001
rev_history = self.revision_history()
1002
rev_history.extend(revision_ids)
1003
self.set_revision_history(rev_history)
1006
def set_revision_history(self, rev_history):
1007
"""See Branch.set_revision_history."""
1008
self.control_files.put_utf8(
1009
'revision-history', '\n'.join(rev_history))
1010
transaction = self.get_transaction()
1011
history = transaction.map.find_revision_history()
1012
if history is not None:
1013
# update the revision history in the identity map.
1014
history[:] = list(rev_history)
1015
# this call is disabled because revision_history is
1016
# not really an object yet, and the transaction is for objects.
1017
# transaction.register_dirty(history)
1019
transaction.map.add_revision_history(rev_history)
1020
# this call is disabled because revision_history is
1021
# not really an object yet, and the transaction is for objects.
1022
# transaction.register_clean(history)
1024
def get_revision_delta(self, revno):
1025
"""Return the delta for one revision.
1027
The delta is relative to its mainline predecessor, or the
1028
empty tree for revision 1.
1030
assert isinstance(revno, int)
1031
rh = self.revision_history()
1032
if not (1 <= revno <= len(rh)):
1033
raise InvalidRevisionNumber(revno)
1035
# revno is 1-based; list is 0-based
1037
new_tree = self.repository.revision_tree(rh[revno-1])
1039
old_tree = EmptyTree()
1041
old_tree = self.repository.revision_tree(rh[revno-2])
1042
return compare_trees(old_tree, new_tree)
1045
def revision_history(self):
1046
"""See Branch.revision_history."""
1047
transaction = self.get_transaction()
1048
history = transaction.map.find_revision_history()
1049
if history is not None:
1050
mutter("cache hit for revision-history in %s", self)
1051
return list(history)
1052
history = [l.rstrip('\r\n') for l in
1053
self.control_files.get_utf8('revision-history').readlines()]
1054
transaction.map.add_revision_history(history)
1055
# this call is disabled because revision_history is
1056
# not really an object yet, and the transaction is for objects.
1057
# transaction.register_clean(history, precious=True)
1058
return list(history)
1061
def update_revisions(self, other, stop_revision=None):
1062
"""See Branch.update_revisions."""
1065
if stop_revision is None:
1066
stop_revision = other.last_revision()
1067
if stop_revision is None:
1068
# if there are no commits, we're done.
1070
# whats the current last revision, before we fetch [and change it
1072
last_rev = self.last_revision()
1073
# we fetch here regardless of whether we need to so that we pickup
1075
self.fetch(other, stop_revision)
1076
my_ancestry = self.repository.get_ancestry(last_rev)
1077
if stop_revision in my_ancestry:
1078
# last_revision is a descendant of stop_revision
1080
# stop_revision must be a descendant of last_revision
1081
stop_graph = self.repository.get_revision_graph(stop_revision)
1082
if last_rev is not None and last_rev not in stop_graph:
1083
# our previous tip is not merged into stop_revision
1084
raise errors.DivergedBranches(self, other)
1085
# make a new revision history from the graph
1086
current_rev_id = stop_revision
1088
while current_rev_id not in (None, NULL_REVISION):
1089
new_history.append(current_rev_id)
1090
current_rev_id_parents = stop_graph[current_rev_id]
1092
current_rev_id = current_rev_id_parents[0]
1094
current_rev_id = None
1095
new_history.reverse()
1096
self.set_revision_history(new_history)
1100
def basis_tree(self):
1101
"""See Branch.basis_tree."""
1102
return self.repository.revision_tree(self.last_revision())
1104
@deprecated_method(zero_eight)
1105
def working_tree(self):
1106
"""Create a Working tree object for this branch."""
1107
from bzrlib.workingtree import WorkingTree
1108
from bzrlib.transport.local import LocalTransport
1109
if (self.base.find('://') != -1 or
1110
not isinstance(self._transport, LocalTransport)):
1111
raise NoWorkingTree(self.base)
1112
return self.bzrdir.open_workingtree()
1115
def pull(self, source, overwrite=False, stop_revision=None):
1116
"""See Branch.pull."""
1119
old_count = len(self.revision_history())
1121
self.update_revisions(source,stop_revision)
1122
except DivergedBranches:
1126
self.set_revision_history(source.revision_history())
1127
new_count = len(self.revision_history())
1128
return new_count - old_count
1132
def get_parent(self):
1133
"""See Branch.get_parent."""
1135
_locs = ['parent', 'pull', 'x-pull']
1136
assert self.base[-1] == '/'
1139
return urlutils.join(self.base[:-1],
1140
self.control_files.get(l).read().strip('\n'))
1145
def get_push_location(self):
1146
"""See Branch.get_push_location."""
1147
config = bzrlib.config.BranchConfig(self)
1148
push_loc = config.get_user_option('push_location')
1151
def set_push_location(self, location):
1152
"""See Branch.set_push_location."""
1153
config = bzrlib.config.LocationConfig(self.base)
1154
config.set_user_option('push_location', location)
1157
def set_parent(self, url):
1158
"""See Branch.set_parent."""
1159
# TODO: Maybe delete old location files?
1160
# URLs should never be unicode, even on the local fs,
1161
# FIXUP this and get_parent in a future branch format bump:
1162
# read and rewrite the file, and have the new format code read
1163
# using .get not .get_utf8. RBC 20060125
1165
self.control_files._transport.delete('parent')
1167
if isinstance(url, unicode):
1169
url = url.encode('ascii')
1170
except UnicodeEncodeError:
1171
raise bzrlib.errors.InvalidURL(url,
1172
"Urls must be 7-bit ascii, "
1173
"use bzrlib.urlutils.escape")
1175
url = urlutils.relative_url(self.base, url)
1176
self.control_files.put('parent', url + '\n')
1178
def tree_config(self):
1179
return TreeConfig(self)
1182
class BzrBranch5(BzrBranch):
1183
"""A format 5 branch. This supports new features over plan branches.
1185
It has support for a master_branch which is the data for bound branches.
1193
super(BzrBranch5, self).__init__(_format=_format,
1194
_control_files=_control_files,
1196
_repository=_repository)
1199
def pull(self, source, overwrite=False, stop_revision=None):
1200
"""Updates branch.pull to be bound branch aware."""
1201
bound_location = self.get_bound_location()
1202
if source.base != bound_location:
1203
# not pulling from master, so we need to update master.
1204
master_branch = self.get_master_branch()
1206
master_branch.pull(source)
1207
source = master_branch
1208
return super(BzrBranch5, self).pull(source, overwrite, stop_revision)
1210
def get_bound_location(self):
1212
return self.control_files.get_utf8('bound').read()[:-1]
1213
except errors.NoSuchFile:
1217
def get_master_branch(self):
1218
"""Return the branch we are bound to.
1220
:return: Either a Branch, or None
1222
This could memoise the branch, but if thats done
1223
it must be revalidated on each new lock.
1224
So for now we just dont memoise it.
1225
# RBC 20060304 review this decision.
1227
bound_loc = self.get_bound_location()
1231
return Branch.open(bound_loc)
1232
except (errors.NotBranchError, errors.ConnectionError), e:
1233
raise errors.BoundBranchConnectionFailure(
1237
def set_bound_location(self, location):
1238
"""Set the target where this branch is bound to.
1240
:param location: URL to the target branch
1243
self.control_files.put_utf8('bound', location+'\n')
1246
self.control_files._transport.delete('bound')
1252
def bind(self, other):
1253
"""Bind the local branch the other branch.
1255
:param other: The branch to bind to
1258
# TODO: jam 20051230 Consider checking if the target is bound
1259
# It is debatable whether you should be able to bind to
1260
# a branch which is itself bound.
1261
# Committing is obviously forbidden,
1262
# but binding itself may not be.
1263
# Since we *have* to check at commit time, we don't
1264
# *need* to check here
1267
# we are now equal to or a suffix of other.
1269
# Since we have 'pulled' from the remote location,
1270
# now we should try to pull in the opposite direction
1271
# in case the local tree has more revisions than the
1273
# There may be a different check you could do here
1274
# rather than actually trying to install revisions remotely.
1275
# TODO: capture an exception which indicates the remote branch
1277
# If it is up-to-date, this probably should not be a failure
1279
# lock other for write so the revision-history syncing cannot race
1283
# if this does not error, other now has the same last rev we do
1284
# it can only error if the pull from other was concurrent with
1285
# a commit to other from someone else.
1287
# until we ditch revision-history, we need to sync them up:
1288
self.set_revision_history(other.revision_history())
1289
# now other and self are up to date with each other and have the
1290
# same revision-history.
1294
self.set_bound_location(other.base)
1298
"""If bound, unbind"""
1299
return self.set_bound_location(None)
1303
"""Synchronise this branch with the master branch if any.
1305
:return: None or the last_revision that was pivoted out during the
1308
master = self.get_master_branch()
1309
if master is not None:
1310
old_tip = self.last_revision()
1311
self.pull(master, overwrite=True)
1312
if old_tip in self.repository.get_ancestry(self.last_revision()):
1318
class BranchTestProviderAdapter(object):
1319
"""A tool to generate a suite testing multiple branch formats at once.
1321
This is done by copying the test once for each transport and injecting
1322
the transport_server, transport_readonly_server, and branch_format
1323
classes into each copy. Each copy is also given a new id() to make it
1327
def __init__(self, transport_server, transport_readonly_server, formats):
1328
self._transport_server = transport_server
1329
self._transport_readonly_server = transport_readonly_server
1330
self._formats = formats
1332
def adapt(self, test):
1333
result = TestSuite()
1334
for branch_format, bzrdir_format in self._formats:
1335
new_test = deepcopy(test)
1336
new_test.transport_server = self._transport_server
1337
new_test.transport_readonly_server = self._transport_readonly_server
1338
new_test.bzrdir_format = bzrdir_format
1339
new_test.branch_format = branch_format
1340
def make_new_test_id():
1341
new_id = "%s(%s)" % (new_test.id(), branch_format.__class__.__name__)
1342
return lambda: new_id
1343
new_test.id = make_new_test_id()
1344
result.addTest(new_test)
1348
######################################################################
1352
@deprecated_function(zero_eight)
1353
def ScratchBranch(*args, **kwargs):
1354
"""See bzrlib.bzrdir.ScratchDir."""
1355
d = ScratchDir(*args, **kwargs)
1356
return d.open_branch()
1359
@deprecated_function(zero_eight)
1360
def is_control_file(*args, **kwargs):
1361
"""See bzrlib.workingtree.is_control_file."""
1362
return bzrlib.workingtree.is_control_file(*args, **kwargs)
added
removed
bzrlib/branch.py
