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, 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.textui import show_status
51
from bzrlib.trace import mutter, note
52
from bzrlib.tree import EmptyTree, RevisionTree
53
from bzrlib.repository import Repository
54
from bzrlib.revision import (
59
from bzrlib.store import copy_all
60
from bzrlib.symbol_versioning import *
61
import bzrlib.transactions as transactions
62
from bzrlib.transport import Transport, get_transport
63
from bzrlib.tree import EmptyTree, RevisionTree
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
self_history = self.revision_history()
305
self_len = len(self_history)
306
other_history = other.revision_history()
307
other_len = len(other_history)
308
common_index = min(self_len, other_len) -1
309
if common_index >= 0 and \
310
self_history[common_index] != other_history[common_index]:
311
raise DivergedBranches(self, other)
313
if stop_revision is None:
314
stop_revision = other_len
316
assert isinstance(stop_revision, int)
317
if stop_revision > other_len:
318
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
319
return other_history[self_len:stop_revision]
321
def update_revisions(self, other, stop_revision=None):
322
"""Pull in new perfect-fit revisions.
324
:param other: Another Branch to pull from
325
:param stop_revision: Updated until the given revision
328
raise NotImplementedError('update_revisions is abstract')
330
def revision_id_to_revno(self, revision_id):
331
"""Given a revision id, return its revno"""
332
if revision_id is None:
334
history = self.revision_history()
336
return history.index(revision_id) + 1
338
raise bzrlib.errors.NoSuchRevision(self, revision_id)
340
def get_rev_id(self, revno, history=None):
341
"""Find the revision id of the specified revno."""
345
history = self.revision_history()
346
elif revno <= 0 or revno > len(history):
347
raise bzrlib.errors.NoSuchRevision(self, revno)
348
return history[revno - 1]
350
def pull(self, source, overwrite=False, stop_revision=None):
351
raise NotImplementedError('pull is abstract')
353
def basis_tree(self):
354
"""Return `Tree` object for last revision.
356
If there are no revisions yet, return an `EmptyTree`.
358
return self.repository.revision_tree(self.last_revision())
360
def rename_one(self, from_rel, to_rel):
363
This can change the directory or the filename or both.
365
raise NotImplementedError('rename_one is abstract')
367
def move(self, from_paths, to_name):
370
to_name must exist as a versioned directory.
372
If to_name exists and is a directory, the files are moved into
373
it, keeping their old names. If it is a directory,
375
Note that to_name is only the last component of the new name;
376
this doesn't change the directory.
378
This returns a list of (from_path, to_path) pairs for each
381
raise NotImplementedError('move is abstract')
383
def get_parent(self):
384
"""Return the parent location of the branch.
386
This is the default location for push/pull/missing. The usual
387
pattern is that the user can override it by specifying a
390
raise NotImplementedError('get_parent is abstract')
392
def get_push_location(self):
393
"""Return the None or the location to push this branch to."""
394
raise NotImplementedError('get_push_location is abstract')
396
def set_push_location(self, location):
397
"""Set a new push location for this branch."""
398
raise NotImplementedError('set_push_location is abstract')
400
def set_parent(self, url):
401
raise NotImplementedError('set_parent is abstract')
405
"""Synchronise this branch with the master branch if any.
407
:return: None or the last_revision pivoted out during the update.
411
def check_revno(self, revno):
413
Check whether a revno corresponds to any revision.
414
Zero (the NULL revision) is considered valid.
417
self.check_real_revno(revno)
419
def check_real_revno(self, revno):
421
Check whether a revno corresponds to a real revision.
422
Zero (the NULL revision) is considered invalid
424
if revno < 1 or revno > self.revno():
425
raise InvalidRevisionNumber(revno)
428
def clone(self, *args, **kwargs):
429
"""Clone this branch into to_bzrdir preserving all semantic values.
431
revision_id: if not None, the revision history in the new branch will
432
be truncated to end with revision_id.
434
# for API compatability, until 0.8 releases we provide the old api:
435
# def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
436
# after 0.8 releases, the *args and **kwargs should be changed:
437
# def clone(self, to_bzrdir, revision_id=None):
438
if (kwargs.get('to_location', None) or
439
kwargs.get('revision', None) or
440
kwargs.get('basis_branch', None) or
441
(len(args) and isinstance(args[0], basestring))):
442
# backwards compatability api:
443
warn("Branch.clone() has been deprecated for BzrDir.clone() from"
444
" bzrlib 0.8.", DeprecationWarning, stacklevel=3)
447
basis_branch = args[2]
449
basis_branch = kwargs.get('basis_branch', None)
451
basis = basis_branch.bzrdir
456
revision_id = args[1]
458
revision_id = kwargs.get('revision', None)
463
# no default to raise if not provided.
464
url = kwargs.get('to_location')
465
return self.bzrdir.clone(url,
466
revision_id=revision_id,
467
basis=basis).open_branch()
469
# generate args by hand
471
revision_id = args[1]
473
revision_id = kwargs.get('revision_id', None)
477
# no default to raise if not provided.
478
to_bzrdir = kwargs.get('to_bzrdir')
479
result = self._format.initialize(to_bzrdir)
480
self.copy_content_into(result, revision_id=revision_id)
484
def sprout(self, to_bzrdir, revision_id=None):
485
"""Create a new line of development from the branch, into to_bzrdir.
487
revision_id: if not None, the revision history in the new branch will
488
be truncated to end with revision_id.
490
result = self._format.initialize(to_bzrdir)
491
self.copy_content_into(result, revision_id=revision_id)
492
result.set_parent(self.bzrdir.root_transport.base)
496
def copy_content_into(self, destination, revision_id=None):
497
"""Copy the content of self into destination.
499
revision_id: if not None, the revision history in the new branch will
500
be truncated to end with revision_id.
502
new_history = self.revision_history()
503
if revision_id is not None:
505
new_history = new_history[:new_history.index(revision_id) + 1]
507
rev = self.repository.get_revision(revision_id)
508
new_history = rev.get_history(self.repository)[1:]
509
destination.set_revision_history(new_history)
510
parent = self.get_parent()
512
destination.set_parent(parent)
515
class BranchFormat(object):
516
"""An encapsulation of the initialization and open routines for a format.
518
Formats provide three things:
519
* An initialization routine,
523
Formats are placed in an dict by their format string for reference
524
during branch opening. Its not required that these be instances, they
525
can be classes themselves with class methods - it simply depends on
526
whether state is needed for a given format or not.
528
Once a format is deprecated, just deprecate the initialize and open
529
methods on the format class. Do not deprecate the object, as the
530
object will be created every time regardless.
533
_default_format = None
534
"""The default format used for new branches."""
537
"""The known formats."""
540
def find_format(klass, a_bzrdir):
541
"""Return the format for the branch object in a_bzrdir."""
543
transport = a_bzrdir.get_branch_transport(None)
544
format_string = transport.get("format").read()
545
return klass._formats[format_string]
547
raise NotBranchError(path=transport.base)
549
raise errors.UnknownFormatError(format=format_string)
552
def get_default_format(klass):
553
"""Return the current default format."""
554
return klass._default_format
556
def get_format_string(self):
557
"""Return the ASCII format string that identifies this format."""
558
raise NotImplementedError(self.get_format_string)
560
def get_format_description(self):
561
"""Return the short format description for this format."""
562
raise NotImplementedError(self.get_format_string)
564
def initialize(self, a_bzrdir):
565
"""Create a branch of this format in a_bzrdir."""
566
raise NotImplementedError(self.initialized)
568
def is_supported(self):
569
"""Is this format supported?
571
Supported formats can be initialized and opened.
572
Unsupported formats may not support initialization or committing or
573
some other features depending on the reason for not being supported.
577
def open(self, a_bzrdir, _found=False):
578
"""Return the branch object for a_bzrdir
580
_found is a private parameter, do not use it. It is used to indicate
581
if format probing has already be done.
583
raise NotImplementedError(self.open)
586
def register_format(klass, format):
587
klass._formats[format.get_format_string()] = format
590
def set_default_format(klass, format):
591
klass._default_format = format
594
def unregister_format(klass, format):
595
assert klass._formats[format.get_format_string()] is format
596
del klass._formats[format.get_format_string()]
599
return self.get_format_string().rstrip()
602
class BzrBranchFormat4(BranchFormat):
603
"""Bzr branch format 4.
606
- a revision-history file.
607
- a branch-lock lock file [ to be shared with the bzrdir ]
610
def get_format_description(self):
611
"""See BranchFormat.get_format_description()."""
612
return "Branch format 4"
614
def initialize(self, a_bzrdir):
615
"""Create a branch of this format in a_bzrdir."""
616
mutter('creating branch in %s', a_bzrdir.transport.base)
617
branch_transport = a_bzrdir.get_branch_transport(self)
618
utf8_files = [('revision-history', ''),
621
control_files = LockableFiles(branch_transport, 'branch-lock',
623
control_files.create_lock()
624
control_files.lock_write()
626
for file, content in utf8_files:
627
control_files.put_utf8(file, content)
629
control_files.unlock()
630
return self.open(a_bzrdir, _found=True)
633
super(BzrBranchFormat4, self).__init__()
634
self._matchingbzrdir = bzrdir.BzrDirFormat6()
636
def open(self, a_bzrdir, _found=False):
637
"""Return the branch object for a_bzrdir
639
_found is a private parameter, do not use it. It is used to indicate
640
if format probing has already be done.
643
# we are being called directly and must probe.
644
raise NotImplementedError
645
return BzrBranch(_format=self,
646
_control_files=a_bzrdir._control_files,
648
_repository=a_bzrdir.open_repository())
651
return "Bazaar-NG branch format 4"
654
class BzrBranchFormat5(BranchFormat):
655
"""Bzr branch format 5.
658
- a revision-history file.
660
- a lock dir guarding the branch itself
661
- all of this stored in a branch/ subdirectory
662
- works with shared repositories.
664
This format is new in bzr 0.8.
667
def get_format_string(self):
668
"""See BranchFormat.get_format_string()."""
669
return "Bazaar-NG branch format 5\n"
671
def get_format_description(self):
672
"""See BranchFormat.get_format_description()."""
673
return "Branch format 5"
675
def initialize(self, a_bzrdir):
676
"""Create a branch of this format in a_bzrdir."""
677
mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
678
branch_transport = a_bzrdir.get_branch_transport(self)
679
utf8_files = [('revision-history', ''),
682
control_files = LockableFiles(branch_transport, 'lock', LockDir)
683
control_files.create_lock()
684
control_files.lock_write()
685
control_files.put_utf8('format', self.get_format_string())
687
for file, content in utf8_files:
688
control_files.put_utf8(file, content)
690
control_files.unlock()
691
return self.open(a_bzrdir, _found=True, )
694
super(BzrBranchFormat5, self).__init__()
695
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
697
def open(self, a_bzrdir, _found=False):
698
"""Return the branch object for a_bzrdir
700
_found is a private parameter, do not use it. It is used to indicate
701
if format probing has already be done.
704
format = BranchFormat.find_format(a_bzrdir)
705
assert format.__class__ == self.__class__
706
transport = a_bzrdir.get_branch_transport(None)
707
control_files = LockableFiles(transport, 'lock', LockDir)
708
return BzrBranch5(_format=self,
709
_control_files=control_files,
711
_repository=a_bzrdir.find_repository())
714
return "Bazaar-NG Metadir branch format 5"
717
class BranchReferenceFormat(BranchFormat):
718
"""Bzr branch reference format.
720
Branch references are used in implementing checkouts, they
721
act as an alias to the real branch which is at some other url.
728
def get_format_string(self):
729
"""See BranchFormat.get_format_string()."""
730
return "Bazaar-NG Branch Reference Format 1\n"
732
def get_format_description(self):
733
"""See BranchFormat.get_format_description()."""
734
return "Checkout reference format 1"
736
def initialize(self, a_bzrdir, target_branch=None):
737
"""Create a branch of this format in a_bzrdir."""
738
if target_branch is None:
739
# this format does not implement branch itself, thus the implicit
740
# creation contract must see it as uninitializable
741
raise errors.UninitializableFormat(self)
742
mutter('creating branch reference in %s', a_bzrdir.transport.base)
743
branch_transport = a_bzrdir.get_branch_transport(self)
744
# FIXME rbc 20060209 one j-a-ms encoding branch lands this str() cast is not needed.
745
branch_transport.put('location', StringIO(str(target_branch.bzrdir.root_transport.base)))
746
branch_transport.put('format', StringIO(self.get_format_string()))
747
return self.open(a_bzrdir, _found=True)
750
super(BranchReferenceFormat, self).__init__()
751
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
753
def _make_reference_clone_function(format, a_branch):
754
"""Create a clone() routine for a branch dynamically."""
755
def clone(to_bzrdir, revision_id=None):
756
"""See Branch.clone()."""
757
return format.initialize(to_bzrdir, a_branch)
758
# cannot obey revision_id limits when cloning a reference ...
759
# FIXME RBC 20060210 either nuke revision_id for clone, or
760
# emit some sort of warning/error to the caller ?!
763
def open(self, a_bzrdir, _found=False):
764
"""Return the branch that the branch reference in a_bzrdir points at.
766
_found is a private parameter, do not use it. It is used to indicate
767
if format probing has already be done.
770
format = BranchFormat.find_format(a_bzrdir)
771
assert format.__class__ == self.__class__
772
transport = a_bzrdir.get_branch_transport(None)
773
real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
774
result = real_bzrdir.open_branch()
775
# this changes the behaviour of result.clone to create a new reference
776
# rather than a copy of the content of the branch.
777
# I did not use a proxy object because that needs much more extensive
778
# testing, and we are only changing one behaviour at the moment.
779
# If we decide to alter more behaviours - i.e. the implicit nickname
780
# then this should be refactored to introduce a tested proxy branch
781
# and a subclass of that for use in overriding clone() and ....
783
result.clone = self._make_reference_clone_function(result)
787
# formats which have no format string are not discoverable
788
# and not independently creatable, so are not registered.
789
__default_format = BzrBranchFormat5()
790
BranchFormat.register_format(__default_format)
791
BranchFormat.register_format(BranchReferenceFormat())
792
BranchFormat.set_default_format(__default_format)
793
_legacy_formats = [BzrBranchFormat4(),
796
class BzrBranch(Branch):
797
"""A branch stored in the actual filesystem.
799
Note that it's "local" in the context of the filesystem; it doesn't
800
really matter if it's on an nfs/smb/afs/coda/... share, as long as
801
it's writable, and can be accessed via the normal filesystem API.
804
def __init__(self, transport=DEPRECATED_PARAMETER, init=DEPRECATED_PARAMETER,
805
relax_version_check=DEPRECATED_PARAMETER, _format=None,
806
_control_files=None, a_bzrdir=None, _repository=None):
807
"""Create new branch object at a particular location.
809
transport -- A Transport object, defining how to access files.
811
init -- If True, create new control files in a previously
812
unversioned directory. If False, the branch must already
815
relax_version_check -- If true, the usual check for the branch
816
version is not applied. This is intended only for
817
upgrade/recovery type use; it's not guaranteed that
818
all operations will work on old format branches.
821
self.bzrdir = bzrdir.BzrDir.open(transport.base)
823
self.bzrdir = a_bzrdir
824
self._transport = self.bzrdir.transport.clone('..')
825
self._base = self._transport.base
826
self._format = _format
827
if _control_files is None:
828
raise BzrBadParameterMissing('_control_files')
829
self.control_files = _control_files
830
if deprecated_passed(init):
831
warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
832
"deprecated as of bzr 0.8. Please use Branch.create().",
836
# this is slower than before deprecation, oh well never mind.
838
self._initialize(transport.base)
839
self._check_format(_format)
840
if deprecated_passed(relax_version_check):
841
warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
842
"relax_version_check parameter is deprecated as of bzr 0.8. "
843
"Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
847
if (not relax_version_check
848
and not self._format.is_supported()):
849
raise errors.UnsupportedFormatError(format=fmt)
850
if deprecated_passed(transport):
851
warn("BzrBranch.__init__(transport=XXX...): The transport "
852
"parameter is deprecated as of bzr 0.8. "
853
"Please use Branch.open, or bzrdir.open_branch().",
856
self.repository = _repository
859
return '%s(%r)' % (self.__class__.__name__, self.base)
864
# TODO: It might be best to do this somewhere else,
865
# but it is nice for a Branch object to automatically
866
# cache it's information.
867
# Alternatively, we could have the Transport objects cache requests
868
# See the earlier discussion about how major objects (like Branch)
869
# should never expect their __del__ function to run.
870
# XXX: cache_root seems to be unused, 2006-01-13 mbp
871
if hasattr(self, 'cache_root') and self.cache_root is not None:
873
rmtree(self.cache_root)
876
self.cache_root = None
881
base = property(_get_base, doc="The URL for the root of this branch.")
883
def _finish_transaction(self):
884
"""Exit the current transaction."""
885
return self.control_files._finish_transaction()
887
def get_transaction(self):
888
"""Return the current active transaction.
890
If no transaction is active, this returns a passthrough object
891
for which all data is immediately flushed and no caching happens.
893
# this is an explicit function so that we can do tricky stuff
894
# when the storage in rev_storage is elsewhere.
895
# we probably need to hook the two 'lock a location' and
896
# 'have a transaction' together more delicately, so that
897
# we can have two locks (branch and storage) and one transaction
898
# ... and finishing the transaction unlocks both, but unlocking
899
# does not. - RBC 20051121
900
return self.control_files.get_transaction()
902
def _set_transaction(self, transaction):
903
"""Set a new active transaction."""
904
return self.control_files._set_transaction(transaction)
906
def abspath(self, name):
907
"""See Branch.abspath."""
908
return self.control_files._transport.abspath(name)
910
def _check_format(self, format):
911
"""Identify the branch format if needed.
913
The format is stored as a reference to the format object in
914
self._format for code that needs to check it later.
916
The format parameter is either None or the branch format class
917
used to open this branch.
919
FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
922
format = BzrBranchFormat.find_format(self.bzrdir)
923
self._format = format
924
mutter("got branch format %s", self._format)
927
def get_root_id(self):
928
"""See Branch.get_root_id."""
929
tree = self.repository.revision_tree(self.last_revision())
930
return tree.inventory.root.file_id
933
return self.control_files.is_locked()
935
def lock_write(self):
936
# TODO: test for failed two phase locks. This is known broken.
937
self.control_files.lock_write()
938
self.repository.lock_write()
941
# TODO: test for failed two phase locks. This is known broken.
942
self.control_files.lock_read()
943
self.repository.lock_read()
946
# TODO: test for failed two phase locks. This is known broken.
948
self.repository.unlock()
950
self.control_files.unlock()
952
def peek_lock_mode(self):
953
if self.control_files._lock_count == 0:
956
return self.control_files._lock_mode
958
def get_physical_lock_status(self):
959
return self.control_files.get_physical_lock_status()
962
def print_file(self, file, revision_id):
963
"""See Branch.print_file."""
964
return self.repository.print_file(file, revision_id)
967
def append_revision(self, *revision_ids):
968
"""See Branch.append_revision."""
969
for revision_id in revision_ids:
970
mutter("add {%s} to revision-history" % revision_id)
971
rev_history = self.revision_history()
972
rev_history.extend(revision_ids)
973
self.set_revision_history(rev_history)
976
def set_revision_history(self, rev_history):
977
"""See Branch.set_revision_history."""
978
self.control_files.put_utf8(
979
'revision-history', '\n'.join(rev_history))
980
transaction = self.get_transaction()
981
history = transaction.map.find_revision_history()
982
if history is not None:
983
# update the revision history in the identity map.
984
history[:] = list(rev_history)
985
# this call is disabled because revision_history is
986
# not really an object yet, and the transaction is for objects.
987
# transaction.register_dirty(history)
989
transaction.map.add_revision_history(rev_history)
990
# this call is disabled because revision_history is
991
# not really an object yet, and the transaction is for objects.
992
# transaction.register_clean(history)
994
def get_revision_delta(self, revno):
995
"""Return the delta for one revision.
997
The delta is relative to its mainline predecessor, or the
998
empty tree for revision 1.
1000
assert isinstance(revno, int)
1001
rh = self.revision_history()
1002
if not (1 <= revno <= len(rh)):
1003
raise InvalidRevisionNumber(revno)
1005
# revno is 1-based; list is 0-based
1007
new_tree = self.repository.revision_tree(rh[revno-1])
1009
old_tree = EmptyTree()
1011
old_tree = self.repository.revision_tree(rh[revno-2])
1012
return compare_trees(old_tree, new_tree)
1015
def revision_history(self):
1016
"""See Branch.revision_history."""
1017
transaction = self.get_transaction()
1018
history = transaction.map.find_revision_history()
1019
if history is not None:
1020
mutter("cache hit for revision-history in %s", self)
1021
return list(history)
1022
history = [l.rstrip('\r\n') for l in
1023
self.control_files.get_utf8('revision-history').readlines()]
1024
transaction.map.add_revision_history(history)
1025
# this call is disabled because revision_history is
1026
# not really an object yet, and the transaction is for objects.
1027
# transaction.register_clean(history, precious=True)
1028
return list(history)
1031
def update_revisions(self, other, stop_revision=None):
1032
"""See Branch.update_revisions."""
1035
if stop_revision is None:
1036
stop_revision = other.last_revision()
1037
if stop_revision is None:
1038
# if there are no commits, we're done.
1040
# whats the current last revision, before we fetch [and change it
1042
last_rev = self.last_revision()
1043
# we fetch here regardless of whether we need to so that we pickup
1045
self.fetch(other, stop_revision)
1046
my_ancestry = self.repository.get_ancestry(last_rev)
1047
if stop_revision in my_ancestry:
1048
# last_revision is a descendant of stop_revision
1050
# stop_revision must be a descendant of last_revision
1051
stop_graph = self.repository.get_revision_graph(stop_revision)
1052
if last_rev is not None and last_rev not in stop_graph:
1053
# our previous tip is not merged into stop_revision
1054
raise errors.DivergedBranches(self, other)
1055
# make a new revision history from the graph
1056
current_rev_id = stop_revision
1058
while current_rev_id not in (None, NULL_REVISION):
1059
new_history.append(current_rev_id)
1060
current_rev_id_parents = stop_graph[current_rev_id]
1062
current_rev_id = current_rev_id_parents[0]
1064
current_rev_id = None
1065
new_history.reverse()
1066
self.set_revision_history(new_history)
1070
def basis_tree(self):
1071
"""See Branch.basis_tree."""
1072
return self.repository.revision_tree(self.last_revision())
1074
@deprecated_method(zero_eight)
1075
def working_tree(self):
1076
"""Create a Working tree object for this branch."""
1077
from bzrlib.workingtree import WorkingTree
1078
from bzrlib.transport.local import LocalTransport
1079
if (self.base.find('://') != -1 or
1080
not isinstance(self._transport, LocalTransport)):
1081
raise NoWorkingTree(self.base)
1082
return self.bzrdir.open_workingtree()
1085
def pull(self, source, overwrite=False, stop_revision=None):
1086
"""See Branch.pull."""
1089
old_count = len(self.revision_history())
1091
self.update_revisions(source,stop_revision)
1092
except DivergedBranches:
1096
self.set_revision_history(source.revision_history())
1097
new_count = len(self.revision_history())
1098
return new_count - old_count
1102
def get_parent(self):
1103
"""See Branch.get_parent."""
1105
_locs = ['parent', 'pull', 'x-pull']
1108
return self.control_files.get_utf8(l).read().strip('\n')
1113
def get_push_location(self):
1114
"""See Branch.get_push_location."""
1115
config = bzrlib.config.BranchConfig(self)
1116
push_loc = config.get_user_option('push_location')
1119
def set_push_location(self, location):
1120
"""See Branch.set_push_location."""
1121
config = bzrlib.config.LocationConfig(self.base)
1122
config.set_user_option('push_location', location)
1125
def set_parent(self, url):
1126
"""See Branch.set_parent."""
1127
# TODO: Maybe delete old location files?
1128
# URLs should never be unicode, even on the local fs,
1129
# FIXUP this and get_parent in a future branch format bump:
1130
# read and rewrite the file, and have the new format code read
1131
# using .get not .get_utf8. RBC 20060125
1133
self.control_files._transport.delete('parent')
1135
self.control_files.put_utf8('parent', url + '\n')
1137
def tree_config(self):
1138
return TreeConfig(self)
1141
class BzrBranch5(BzrBranch):
1142
"""A format 5 branch. This supports new features over plan branches.
1144
It has support for a master_branch which is the data for bound branches.
1152
super(BzrBranch5, self).__init__(_format=_format,
1153
_control_files=_control_files,
1155
_repository=_repository)
1158
def pull(self, source, overwrite=False, stop_revision=None):
1159
"""Updates branch.pull to be bound branch aware."""
1160
bound_location = self.get_bound_location()
1161
if source.base != bound_location:
1162
# not pulling from master, so we need to update master.
1163
master_branch = self.get_master_branch()
1165
master_branch.pull(source)
1166
source = master_branch
1167
return super(BzrBranch5, self).pull(source, overwrite, stop_revision)
1169
def get_bound_location(self):
1171
return self.control_files.get_utf8('bound').read()[:-1]
1172
except errors.NoSuchFile:
1176
def get_master_branch(self):
1177
"""Return the branch we are bound to.
1179
:return: Either a Branch, or None
1181
This could memoise the branch, but if thats done
1182
it must be revalidated on each new lock.
1183
So for now we just dont memoise it.
1184
# RBC 20060304 review this decision.
1186
bound_loc = self.get_bound_location()
1190
return Branch.open(bound_loc)
1191
except (errors.NotBranchError, errors.ConnectionError), e:
1192
raise errors.BoundBranchConnectionFailure(
1196
def set_bound_location(self, location):
1197
"""Set the target where this branch is bound to.
1199
:param location: URL to the target branch
1202
self.control_files.put_utf8('bound', location+'\n')
1205
self.control_files._transport.delete('bound')
1211
def bind(self, other):
1212
"""Bind the local branch the other branch.
1214
:param other: The branch to bind to
1217
# TODO: jam 20051230 Consider checking if the target is bound
1218
# It is debatable whether you should be able to bind to
1219
# a branch which is itself bound.
1220
# Committing is obviously forbidden,
1221
# but binding itself may not be.
1222
# Since we *have* to check at commit time, we don't
1223
# *need* to check here
1226
# we are now equal to or a suffix of other.
1228
# Since we have 'pulled' from the remote location,
1229
# now we should try to pull in the opposite direction
1230
# in case the local tree has more revisions than the
1232
# There may be a different check you could do here
1233
# rather than actually trying to install revisions remotely.
1234
# TODO: capture an exception which indicates the remote branch
1236
# If it is up-to-date, this probably should not be a failure
1238
# lock other for write so the revision-history syncing cannot race
1242
# if this does not error, other now has the same last rev we do
1243
# it can only error if the pull from other was concurrent with
1244
# a commit to other from someone else.
1246
# until we ditch revision-history, we need to sync them up:
1247
self.set_revision_history(other.revision_history())
1248
# now other and self are up to date with each other and have the
1249
# same revision-history.
1253
self.set_bound_location(other.base)
1257
"""If bound, unbind"""
1258
return self.set_bound_location(None)
1262
"""Synchronise this branch with the master branch if any.
1264
:return: None or the last_revision that was pivoted out during the
1267
master = self.get_master_branch()
1268
if master is not None:
1269
old_tip = self.last_revision()
1270
self.pull(master, overwrite=True)
1271
if old_tip in self.repository.get_ancestry(self.last_revision()):
1277
class BranchTestProviderAdapter(object):
1278
"""A tool to generate a suite testing multiple branch formats at once.
1280
This is done by copying the test once for each transport and injecting
1281
the transport_server, transport_readonly_server, and branch_format
1282
classes into each copy. Each copy is also given a new id() to make it
1286
def __init__(self, transport_server, transport_readonly_server, formats):
1287
self._transport_server = transport_server
1288
self._transport_readonly_server = transport_readonly_server
1289
self._formats = formats
1291
def adapt(self, test):
1292
result = TestSuite()
1293
for branch_format, bzrdir_format in self._formats:
1294
new_test = deepcopy(test)
1295
new_test.transport_server = self._transport_server
1296
new_test.transport_readonly_server = self._transport_readonly_server
1297
new_test.bzrdir_format = bzrdir_format
1298
new_test.branch_format = branch_format
1299
def make_new_test_id():
1300
new_id = "%s(%s)" % (new_test.id(), branch_format.__class__.__name__)
1301
return lambda: new_id
1302
new_test.id = make_new_test_id()
1303
result.addTest(new_test)
1307
######################################################################
1311
@deprecated_function(zero_eight)
1312
def ScratchBranch(*args, **kwargs):
1313
"""See bzrlib.bzrdir.ScratchDir."""
1314
d = ScratchDir(*args, **kwargs)
1315
return d.open_branch()
1318
@deprecated_function(zero_eight)
1319
def is_control_file(*args, **kwargs):
1320
"""See bzrlib.workingtree.is_control_file."""
1321
return bzrlib.workingtree.is_control_file(*args, **kwargs)
added
removed
bzrlib/branch.py
