1
# Copyright (C) 2005 Canonical Ltd
1
# Copyright (C) 2005, 2006 Canonical Ltd
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
11
# GNU General Public License for more details.
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18
from copy import deepcopy
19
from cStringIO import StringIO
20
from unittest import TestSuite
22
21
from warnings import warn
23
from cStringIO import StringIO
27
import bzrlib.inventory as inventory
36
from bzrlib.config import TreeConfig
37
from bzrlib.decorators import needs_read_lock, needs_write_lock
38
import bzrlib.errors as errors
39
from bzrlib.errors import (BzrError, BzrCheckError, DivergedBranches,
40
HistoryMissing, InvalidRevisionId,
41
InvalidRevisionNumber, LockError, NoSuchFile,
42
NoSuchRevision, NoWorkingTree, NotVersionedError,
43
NotBranchError, UninitializableFormat,
44
UnlistableStore, UnlistableBranch,
46
from bzrlib.lockable_files import LockableFiles, TransportLock
47
from bzrlib.symbol_versioning import (deprecated_function,
51
zero_eight, zero_nine,
28
53
from bzrlib.trace import mutter, note
29
from bzrlib.osutils import (isdir, quotefn,
30
rename, splitpath, sha_file, appendpath,
32
import bzrlib.errors as errors
33
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
34
NoSuchRevision, HistoryMissing, NotBranchError,
35
DivergedBranches, LockError, UnlistableStore,
36
UnlistableBranch, NoSuchFile, NotVersionedError,
38
from bzrlib.textui import show_status
39
from bzrlib.revision import (Revision, is_ancestor, get_intervening_revisions,
42
from bzrlib.delta import compare_trees
43
from bzrlib.tree import EmptyTree, RevisionTree
44
from bzrlib.inventory import Inventory
45
from bzrlib.store import copy_all
46
from bzrlib.store.text import TextStore
47
from bzrlib.store.weave import WeaveStore
48
from bzrlib.testament import Testament
49
import bzrlib.transactions as transactions
50
from bzrlib.transport import Transport, get_transport
53
from config import TreeConfig
56
56
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
57
57
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
58
58
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
59
## TODO: Maybe include checks for common corruption of newlines, etc?
61
# TODO: Maybe include checks for common corruption of newlines, etc?
62
63
# TODO: Some operations like log might retrieve the same revisions
63
64
# repeatedly to calculate deltas. We could perhaps have a weakref
64
65
# cache in memory to make this faster. In general anything can be
65
# cached in memory between lock and unlock operations.
67
def find_branch(*ignored, **ignored_too):
68
# XXX: leave this here for about one release, then remove it
69
raise NotImplementedError('find_branch() is not supported anymore, '
70
'please use one of the new branch constructors')
73
def needs_read_lock(unbound):
74
"""Decorate unbound to take out and release a read lock."""
75
def decorated(self, *args, **kwargs):
78
return unbound(self, *args, **kwargs)
84
def needs_write_lock(unbound):
85
"""Decorate unbound to take out and release a write lock."""
86
def decorated(self, *args, **kwargs):
89
return unbound(self, *args, **kwargs)
66
# cached in memory between lock and unlock operations. .. nb thats
67
# what the transaction identity map provides
94
70
######################################################################
191
183
XXX: Robert Collins 20051017 what is this used for? why is it a branch
192
184
method and not a tree method.
194
raise NotImplementedError('abspath is abstract')
196
def controlfilename(self, file_or_path):
197
"""Return location relative to branch."""
198
raise NotImplementedError('controlfilename is abstract')
200
def controlfile(self, file_or_path, mode='r'):
201
"""Open a control file for this branch.
203
There are two classes of file in the control directory: text
204
and binary. binary files are untranslated byte streams. Text
205
control files are stored with Unix newlines and in UTF-8, even
206
if the platform or locale defaults are different.
208
Controlfiles should almost never be opened in write mode but
209
rather should be atomically copied and replaced using atomicfile.
211
raise NotImplementedError('controlfile is abstract')
213
def put_controlfile(self, path, f, encode=True):
214
"""Write an entry as a controlfile.
216
:param path: The path to put the file, relative to the .bzr control
218
:param f: A file-like or string object whose contents should be copied.
219
:param encode: If true, encode the contents as utf-8
221
raise NotImplementedError('put_controlfile is abstract')
223
def put_controlfiles(self, files, encode=True):
224
"""Write several entries as controlfiles.
226
:param files: A list of [(path, file)] pairs, where the path is the directory
227
underneath the bzr control directory
228
:param encode: If true, encode the contents as utf-8
230
raise NotImplementedError('put_controlfiles is abstract')
232
def get_root_id(self):
233
"""Return the id of this branches root"""
234
raise NotImplementedError('get_root_id is abstract')
236
def set_root_id(self, file_id):
237
raise NotImplementedError('set_root_id is abstract')
239
def print_file(self, file, revision_id):
240
"""Print `file` to stdout."""
241
raise NotImplementedError('print_file is abstract')
243
def append_revision(self, *revision_ids):
244
raise NotImplementedError('append_revision is abstract')
246
def set_revision_history(self, rev_history):
247
raise NotImplementedError('set_revision_history is abstract')
249
def has_revision(self, revision_id):
250
"""True if this branch has a copy of the revision.
252
This does not necessarily imply the revision is merge
253
or on the mainline."""
254
raise NotImplementedError('has_revision is abstract')
256
def get_revision_xml(self, revision_id):
257
raise NotImplementedError('get_revision_xml is abstract')
259
def get_revision(self, revision_id):
260
"""Return the Revision object for a named revision"""
261
raise NotImplementedError('get_revision is abstract')
186
raise NotImplementedError(self.abspath)
188
def bind(self, other):
189
"""Bind the local branch the other branch.
191
:param other: The branch to bind to
194
raise errors.UpgradeRequired(self.base)
197
def fetch(self, from_branch, last_revision=None, pb=None):
198
"""Copy revisions from from_branch into this branch.
200
:param from_branch: Where to copy from.
201
:param last_revision: What revision to stop at (None for at the end
203
:param pb: An optional progress bar to use.
205
Returns the copied revision count and the failed revisions in a tuple:
208
if self.base == from_branch.base:
211
nested_pb = ui.ui_factory.nested_progress_bar()
216
from_branch.lock_read()
218
if last_revision is None:
219
pb.update('get source history')
220
from_history = from_branch.revision_history()
222
last_revision = from_history[-1]
224
# no history in the source branch
225
last_revision = revision.NULL_REVISION
226
return self.repository.fetch(from_branch.repository,
227
revision_id=last_revision,
230
if nested_pb is not None:
234
def get_bound_location(self):
235
"""Return the URL of the branch we are bound to.
237
Older format branches cannot bind, please be sure to use a metadir
242
def get_commit_builder(self, parents, config=None, timestamp=None,
243
timezone=None, committer=None, revprops=None,
245
"""Obtain a CommitBuilder for this branch.
247
:param parents: Revision ids of the parents of the new revision.
248
:param config: Optional configuration to use.
249
:param timestamp: Optional timestamp recorded for commit.
250
:param timezone: Optional timezone for timestamp.
251
:param committer: Optional committer to set for commit.
252
:param revprops: Optional dictionary of revision properties.
253
:param revision_id: Optional revision id.
257
config = self.get_config()
259
return self.repository.get_commit_builder(self, parents, config,
260
timestamp, timezone, committer, revprops, revision_id)
262
def get_master_branch(self):
263
"""Return the branch we are bound to.
265
:return: Either a Branch, or None
263
269
def get_revision_delta(self, revno):
264
270
"""Return the delta for one revision.
481
460
if revno < 1 or revno > self.revno():
482
461
raise InvalidRevisionNumber(revno)
484
def sign_revision(self, revision_id, gpg_strategy):
485
raise NotImplementedError('sign_revision is abstract')
487
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
488
raise NotImplementedError('store_revision_signature is abstract')
464
def clone(self, *args, **kwargs):
465
"""Clone this branch into to_bzrdir preserving all semantic values.
467
revision_id: if not None, the revision history in the new branch will
468
be truncated to end with revision_id.
470
# for API compatibility, until 0.8 releases we provide the old api:
471
# def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
472
# after 0.8 releases, the *args and **kwargs should be changed:
473
# def clone(self, to_bzrdir, revision_id=None):
474
if (kwargs.get('to_location', None) or
475
kwargs.get('revision', None) or
476
kwargs.get('basis_branch', None) or
477
(len(args) and isinstance(args[0], basestring))):
478
# backwards compatibility api:
479
warn("Branch.clone() has been deprecated for BzrDir.clone() from"
480
" bzrlib 0.8.", DeprecationWarning, stacklevel=3)
483
basis_branch = args[2]
485
basis_branch = kwargs.get('basis_branch', None)
487
basis = basis_branch.bzrdir
492
revision_id = args[1]
494
revision_id = kwargs.get('revision', None)
499
# no default to raise if not provided.
500
url = kwargs.get('to_location')
501
return self.bzrdir.clone(url,
502
revision_id=revision_id,
503
basis=basis).open_branch()
505
# generate args by hand
507
revision_id = args[1]
509
revision_id = kwargs.get('revision_id', None)
513
# no default to raise if not provided.
514
to_bzrdir = kwargs.get('to_bzrdir')
515
result = self._format.initialize(to_bzrdir)
516
self.copy_content_into(result, revision_id=revision_id)
520
def sprout(self, to_bzrdir, revision_id=None):
521
"""Create a new line of development from the branch, into to_bzrdir.
523
revision_id: if not None, the revision history in the new branch will
524
be truncated to end with revision_id.
526
result = self._format.initialize(to_bzrdir)
527
self.copy_content_into(result, revision_id=revision_id)
528
result.set_parent(self.bzrdir.root_transport.base)
532
def copy_content_into(self, destination, revision_id=None):
533
"""Copy the content of self into destination.
535
revision_id: if not None, the revision history in the new branch will
536
be truncated to end with revision_id.
538
new_history = self.revision_history()
539
if revision_id is not None:
541
new_history = new_history[:new_history.index(revision_id) + 1]
543
rev = self.repository.get_revision(revision_id)
544
new_history = rev.get_history(self.repository)[1:]
545
destination.set_revision_history(new_history)
547
parent = self.get_parent()
548
except errors.InaccessibleParent, e:
549
mutter('parent was not accessible to copy: %s', e)
552
destination.set_parent(parent)
556
"""Check consistency of the branch.
558
In particular this checks that revisions given in the revision-history
559
do actually match up in the revision graph, and that they're all
560
present in the repository.
562
Callers will typically also want to check the repository.
564
:return: A BranchCheckResult.
566
mainline_parent_id = None
567
for revision_id in self.revision_history():
569
revision = self.repository.get_revision(revision_id)
570
except errors.NoSuchRevision, e:
571
raise errors.BzrCheckError("mainline revision {%s} not in repository"
573
# In general the first entry on the revision history has no parents.
574
# But it's not illegal for it to have parents listed; this can happen
575
# in imports from Arch when the parents weren't reachable.
576
if mainline_parent_id is not None:
577
if mainline_parent_id not in revision.parent_ids:
578
raise errors.BzrCheckError("previous revision {%s} not listed among "
580
% (mainline_parent_id, revision_id))
581
mainline_parent_id = revision_id
582
return BranchCheckResult(self)
584
def create_checkout(self, to_location, revision_id=None,
586
"""Create a checkout of a branch.
588
:param to_location: The url to produce the checkout at
589
:param revision_id: The revision to check out
590
:param lightweight: If True, produce a lightweight checkout, otherwise,
591
produce a bound branch (heavyweight checkout)
592
:return: The tree of the created checkout
595
t = transport.get_transport(to_location)
598
except errors.FileExists:
600
checkout = bzrdir.BzrDirMetaFormat1().initialize_on_transport(t)
601
BranchReferenceFormat().initialize(checkout, self)
603
checkout_branch = bzrdir.BzrDir.create_branch_convenience(
604
to_location, force_new_tree=False)
605
checkout = checkout_branch.bzrdir
606
checkout_branch.bind(self)
607
if revision_id is not None:
608
rh = checkout_branch.revision_history()
609
new_rh = rh[:rh.index(revision_id) + 1]
610
checkout_branch.set_revision_history(new_rh)
611
return checkout.create_workingtree(revision_id)
614
class BranchFormat(object):
615
"""An encapsulation of the initialization and open routines for a format.
617
Formats provide three things:
618
* An initialization routine,
622
Formats are placed in an dict by their format string for reference
623
during branch opening. Its not required that these be instances, they
624
can be classes themselves with class methods - it simply depends on
625
whether state is needed for a given format or not.
627
Once a format is deprecated, just deprecate the initialize and open
628
methods on the format class. Do not deprecate the object, as the
629
object will be created every time regardless.
632
_default_format = None
633
"""The default format used for new branches."""
636
"""The known formats."""
639
def find_format(klass, a_bzrdir):
640
"""Return the format for the branch object in a_bzrdir."""
642
transport = a_bzrdir.get_branch_transport(None)
643
format_string = transport.get("format").read()
644
return klass._formats[format_string]
646
raise NotBranchError(path=transport.base)
648
raise errors.UnknownFormatError(format=format_string)
651
def get_default_format(klass):
652
"""Return the current default format."""
653
return klass._default_format
655
def get_format_string(self):
656
"""Return the ASCII format string that identifies this format."""
657
raise NotImplementedError(self.get_format_string)
659
def get_format_description(self):
660
"""Return the short format description for this format."""
661
raise NotImplementedError(self.get_format_string)
663
def initialize(self, a_bzrdir):
664
"""Create a branch of this format in a_bzrdir."""
665
raise NotImplementedError(self.initialize)
667
def is_supported(self):
668
"""Is this format supported?
670
Supported formats can be initialized and opened.
671
Unsupported formats may not support initialization or committing or
672
some other features depending on the reason for not being supported.
676
def open(self, a_bzrdir, _found=False):
677
"""Return the branch object for a_bzrdir
679
_found is a private parameter, do not use it. It is used to indicate
680
if format probing has already be done.
682
raise NotImplementedError(self.open)
685
def register_format(klass, format):
686
klass._formats[format.get_format_string()] = format
689
def set_default_format(klass, format):
690
klass._default_format = format
693
def unregister_format(klass, format):
694
assert klass._formats[format.get_format_string()] is format
695
del klass._formats[format.get_format_string()]
698
return self.get_format_string().rstrip()
701
class BzrBranchFormat4(BranchFormat):
702
"""Bzr branch format 4.
705
- a revision-history file.
706
- a branch-lock lock file [ to be shared with the bzrdir ]
709
def get_format_description(self):
710
"""See BranchFormat.get_format_description()."""
711
return "Branch format 4"
713
def initialize(self, a_bzrdir):
714
"""Create a branch of this format in a_bzrdir."""
715
mutter('creating branch in %s', a_bzrdir.transport.base)
716
branch_transport = a_bzrdir.get_branch_transport(self)
717
utf8_files = [('revision-history', ''),
720
control_files = LockableFiles(branch_transport, 'branch-lock',
722
control_files.create_lock()
723
control_files.lock_write()
725
for file, content in utf8_files:
726
control_files.put_utf8(file, content)
728
control_files.unlock()
729
return self.open(a_bzrdir, _found=True)
732
super(BzrBranchFormat4, self).__init__()
733
self._matchingbzrdir = bzrdir.BzrDirFormat6()
735
def open(self, a_bzrdir, _found=False):
736
"""Return the branch object for a_bzrdir
738
_found is a private parameter, do not use it. It is used to indicate
739
if format probing has already be done.
742
# we are being called directly and must probe.
743
raise NotImplementedError
744
return BzrBranch(_format=self,
745
_control_files=a_bzrdir._control_files,
747
_repository=a_bzrdir.open_repository())
750
return "Bazaar-NG branch format 4"
753
class BzrBranchFormat5(BranchFormat):
754
"""Bzr branch format 5.
757
- a revision-history file.
759
- a lock dir guarding the branch itself
760
- all of this stored in a branch/ subdirectory
761
- works with shared repositories.
763
This format is new in bzr 0.8.
766
def get_format_string(self):
767
"""See BranchFormat.get_format_string()."""
768
return "Bazaar-NG branch format 5\n"
770
def get_format_description(self):
771
"""See BranchFormat.get_format_description()."""
772
return "Branch format 5"
774
def initialize(self, a_bzrdir):
775
"""Create a branch of this format in a_bzrdir."""
776
mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
777
branch_transport = a_bzrdir.get_branch_transport(self)
778
utf8_files = [('revision-history', ''),
781
control_files = LockableFiles(branch_transport, 'lock', lockdir.LockDir)
782
control_files.create_lock()
783
control_files.lock_write()
784
control_files.put_utf8('format', self.get_format_string())
786
for file, content in utf8_files:
787
control_files.put_utf8(file, content)
789
control_files.unlock()
790
return self.open(a_bzrdir, _found=True, )
793
super(BzrBranchFormat5, self).__init__()
794
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
796
def open(self, a_bzrdir, _found=False):
797
"""Return the branch object for a_bzrdir
799
_found is a private parameter, do not use it. It is used to indicate
800
if format probing has already be done.
803
format = BranchFormat.find_format(a_bzrdir)
804
assert format.__class__ == self.__class__
805
transport = a_bzrdir.get_branch_transport(None)
806
control_files = LockableFiles(transport, 'lock', lockdir.LockDir)
807
return BzrBranch5(_format=self,
808
_control_files=control_files,
810
_repository=a_bzrdir.find_repository())
813
return "Bazaar-NG Metadir branch format 5"
816
class BranchReferenceFormat(BranchFormat):
817
"""Bzr branch reference format.
819
Branch references are used in implementing checkouts, they
820
act as an alias to the real branch which is at some other url.
827
def get_format_string(self):
828
"""See BranchFormat.get_format_string()."""
829
return "Bazaar-NG Branch Reference Format 1\n"
831
def get_format_description(self):
832
"""See BranchFormat.get_format_description()."""
833
return "Checkout reference format 1"
835
def initialize(self, a_bzrdir, target_branch=None):
836
"""Create a branch of this format in a_bzrdir."""
837
if target_branch is None:
838
# this format does not implement branch itself, thus the implicit
839
# creation contract must see it as uninitializable
840
raise errors.UninitializableFormat(self)
841
mutter('creating branch reference in %s', a_bzrdir.transport.base)
842
branch_transport = a_bzrdir.get_branch_transport(self)
843
# FIXME rbc 20060209 one j-a-ms encoding branch lands this str() cast is not needed.
844
branch_transport.put('location', StringIO(str(target_branch.bzrdir.root_transport.base)))
845
branch_transport.put('format', StringIO(self.get_format_string()))
846
return self.open(a_bzrdir, _found=True)
849
super(BranchReferenceFormat, self).__init__()
850
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
852
def _make_reference_clone_function(format, a_branch):
853
"""Create a clone() routine for a branch dynamically."""
854
def clone(to_bzrdir, revision_id=None):
855
"""See Branch.clone()."""
856
return format.initialize(to_bzrdir, a_branch)
857
# cannot obey revision_id limits when cloning a reference ...
858
# FIXME RBC 20060210 either nuke revision_id for clone, or
859
# emit some sort of warning/error to the caller ?!
862
def open(self, a_bzrdir, _found=False):
863
"""Return the branch that the branch reference in a_bzrdir points at.
865
_found is a private parameter, do not use it. It is used to indicate
866
if format probing has already be done.
869
format = BranchFormat.find_format(a_bzrdir)
870
assert format.__class__ == self.__class__
871
transport = a_bzrdir.get_branch_transport(None)
872
real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
873
result = real_bzrdir.open_branch()
874
# this changes the behaviour of result.clone to create a new reference
875
# rather than a copy of the content of the branch.
876
# I did not use a proxy object because that needs much more extensive
877
# testing, and we are only changing one behaviour at the moment.
878
# If we decide to alter more behaviours - i.e. the implicit nickname
879
# then this should be refactored to introduce a tested proxy branch
880
# and a subclass of that for use in overriding clone() and ....
882
result.clone = self._make_reference_clone_function(result)
886
# formats which have no format string are not discoverable
887
# and not independently creatable, so are not registered.
888
__default_format = BzrBranchFormat5()
889
BranchFormat.register_format(__default_format)
890
BranchFormat.register_format(BranchReferenceFormat())
891
BranchFormat.set_default_format(__default_format)
892
_legacy_formats = [BzrBranchFormat4(),
490
895
class BzrBranch(Branch):
491
896
"""A branch stored in the actual filesystem.
552
915
version is not applied. This is intended only for
553
916
upgrade/recovery type use; it's not guaranteed that
554
917
all operations will work on old format branches.
556
In the test suite, creation of new trees is tested using the
557
`ScratchBranch` class.
559
assert isinstance(transport, Transport), \
560
"%r is not a Transport" % transport
561
self._transport = transport
564
self._check_format(relax_version_check)
566
def get_store(name, compressed=True, prefixed=False):
567
# FIXME: This approach of assuming stores are all entirely compressed
568
# or entirely uncompressed is tidy, but breaks upgrade from
569
# some existing branches where there's a mixture; we probably
570
# still want the option to look for both.
571
relpath = self._rel_controlfilename(name)
572
store = TextStore(self._transport.clone(relpath),
574
compressed=compressed)
575
#if self._transport.should_cache():
576
# cache_path = os.path.join(self.cache_root, name)
577
# os.mkdir(cache_path)
578
# store = bzrlib.store.CachedStore(store, cache_path)
580
def get_weave(name, prefixed=False):
581
relpath = self._rel_controlfilename(name)
582
ws = WeaveStore(self._transport.clone(relpath), prefixed=prefixed)
583
if self._transport.should_cache():
584
ws.enable_cache = True
587
if self._branch_format == 4:
588
self.inventory_store = get_store(u'inventory-store')
589
self.text_store = get_store(u'text-store')
590
self.revision_store = get_store(u'revision-store')
591
elif self._branch_format == 5:
592
self.control_weaves = get_weave(u'')
593
self.weave_store = get_weave(u'weaves')
594
self.revision_store = get_store(u'revision-store', compressed=False)
595
elif self._branch_format == 6:
596
self.control_weaves = get_weave(u'')
597
self.weave_store = get_weave(u'weaves', prefixed=True)
598
self.revision_store = get_store(u'revision-store', compressed=False,
600
self.revision_store.register_suffix('sig')
601
self._transaction = None
920
self.bzrdir = bzrdir.BzrDir.open(transport.base)
922
self.bzrdir = a_bzrdir
923
self._transport = self.bzrdir.transport.clone('..')
924
self._base = self._transport.base
925
self._format = _format
926
if _control_files is None:
927
raise ValueError('BzrBranch _control_files is None')
928
self.control_files = _control_files
929
if deprecated_passed(init):
930
warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
931
"deprecated as of bzr 0.8. Please use Branch.create().",
935
# this is slower than before deprecation, oh well never mind.
937
self._initialize(transport.base)
938
self._check_format(_format)
939
if deprecated_passed(relax_version_check):
940
warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
941
"relax_version_check parameter is deprecated as of bzr 0.8. "
942
"Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
946
if (not relax_version_check
947
and not self._format.is_supported()):
948
raise errors.UnsupportedFormatError(format=fmt)
949
if deprecated_passed(transport):
950
warn("BzrBranch.__init__(transport=XXX...): The transport "
951
"parameter is deprecated as of bzr 0.8. "
952
"Please use Branch.open, or bzrdir.open_branch().",
955
self.repository = _repository
603
957
def __str__(self):
604
return '%s(%r)' % (self.__class__.__name__, self._transport.base)
958
return '%s(%r)' % (self.__class__.__name__, self.base)
606
960
__repr__ = __str__
609
if self._lock_mode or self._lock:
610
# XXX: This should show something every time, and be suitable for
611
# headless operation and embedding
612
warn("branch %r was not explicitly unlocked" % self)
615
# TODO: It might be best to do this somewhere else,
616
# but it is nice for a Branch object to automatically
617
# cache it's information.
618
# Alternatively, we could have the Transport objects cache requests
619
# See the earlier discussion about how major objects (like Branch)
620
# should never expect their __del__ function to run.
621
if hasattr(self, 'cache_root') and self.cache_root is not None:
623
shutil.rmtree(self.cache_root)
626
self.cache_root = None
628
962
def _get_base(self):
630
return self._transport.base
633
965
base = property(_get_base, doc="The URL for the root of this branch.")
635
967
def _finish_transaction(self):
636
968
"""Exit the current transaction."""
637
if self._transaction is None:
638
raise errors.LockError('Branch %s is not in a transaction' %
640
transaction = self._transaction
641
self._transaction = None
969
return self.control_files._finish_transaction()
644
971
def get_transaction(self):
645
"""See Branch.get_transaction."""
646
if self._transaction is None:
647
return transactions.PassThroughTransaction()
649
return self._transaction
651
def _set_transaction(self, new_transaction):
972
"""Return the current active transaction.
974
If no transaction is active, this returns a passthrough object
975
for which all data is immediately flushed and no caching happens.
977
# this is an explicit function so that we can do tricky stuff
978
# when the storage in rev_storage is elsewhere.
979
# we probably need to hook the two 'lock a location' and
980
# 'have a transaction' together more delicately, so that
981
# we can have two locks (branch and storage) and one transaction
982
# ... and finishing the transaction unlocks both, but unlocking
983
# does not. - RBC 20051121
984
return self.control_files.get_transaction()
986
def _set_transaction(self, transaction):
652
987
"""Set a new active transaction."""
653
if self._transaction is not None:
654
raise errors.LockError('Branch %s is in a transaction already.' %
656
self._transaction = new_transaction
658
def lock_write(self):
659
#mutter("lock write: %s (%s)", self, self._lock_count)
660
# TODO: Upgrade locking to support using a Transport,
661
# and potentially a remote locking protocol
663
if self._lock_mode != 'w':
664
raise LockError("can't upgrade to a write lock from %r" %
666
self._lock_count += 1
668
self._lock = self._transport.lock_write(
669
self._rel_controlfilename('branch-lock'))
670
self._lock_mode = 'w'
672
self._set_transaction(transactions.PassThroughTransaction())
675
#mutter("lock read: %s (%s)", self, self._lock_count)
677
assert self._lock_mode in ('r', 'w'), \
678
"invalid lock mode %r" % self._lock_mode
679
self._lock_count += 1
681
self._lock = self._transport.lock_read(
682
self._rel_controlfilename('branch-lock'))
683
self._lock_mode = 'r'
685
self._set_transaction(transactions.ReadOnlyTransaction())
686
# 5K may be excessive, but hey, its a knob.
687
self.get_transaction().set_cache_size(5000)
690
#mutter("unlock: %s (%s)", self, self._lock_count)
691
if not self._lock_mode:
692
raise LockError('branch %r is not locked' % (self))
694
if self._lock_count > 1:
695
self._lock_count -= 1
697
self._finish_transaction()
700
self._lock_mode = self._lock_count = None
988
return self.control_files._set_transaction(transaction)
702
990
def abspath(self, name):
703
991
"""See Branch.abspath."""
704
return self._transport.abspath(name)
706
def _rel_controlfilename(self, file_or_path):
707
if not isinstance(file_or_path, basestring):
708
file_or_path = u'/'.join(file_or_path)
709
if file_or_path == '':
711
return bzrlib.transport.urlescape(bzrlib.BZRDIR + u'/' + file_or_path)
713
def controlfilename(self, file_or_path):
714
"""See Branch.controlfilename."""
715
return self._transport.abspath(self._rel_controlfilename(file_or_path))
717
def controlfile(self, file_or_path, mode='r'):
718
"""See Branch.controlfile."""
721
relpath = self._rel_controlfilename(file_or_path)
722
#TODO: codecs.open() buffers linewise, so it was overloaded with
723
# a much larger buffer, do we need to do the same for getreader/getwriter?
725
return self._transport.get(relpath)
727
raise BzrError("Branch.controlfile(mode='wb') is not supported, use put_controlfiles")
729
# XXX: Do we really want errors='replace'? Perhaps it should be
730
# an error, or at least reported, if there's incorrectly-encoded
731
# data inside a file.
732
# <https://launchpad.net/products/bzr/+bug/3823>
733
return codecs.getreader('utf-8')(self._transport.get(relpath), errors='replace')
735
raise BzrError("Branch.controlfile(mode='w') is not supported, use put_controlfiles")
737
raise BzrError("invalid controlfile mode %r" % mode)
739
def put_controlfile(self, path, f, encode=True):
740
"""See Branch.put_controlfile."""
741
self.put_controlfiles([(path, f)], encode=encode)
743
def put_controlfiles(self, files, encode=True):
744
"""See Branch.put_controlfiles."""
747
for path, f in files:
749
if isinstance(f, basestring):
750
f = f.encode('utf-8', 'replace')
752
f = codecs.getwriter('utf-8')(f, errors='replace')
753
path = self._rel_controlfilename(path)
754
ctrl_files.append((path, f))
755
self._transport.put_multi(ctrl_files)
757
def _make_control(self):
758
from bzrlib.inventory import Inventory
759
from bzrlib.weavefile import write_weave_v5
760
from bzrlib.weave import Weave
762
# Create an empty inventory
764
# if we want per-tree root ids then this is the place to set
765
# them; they're not needed for now and so ommitted for
767
bzrlib.xml5.serializer_v5.write_inventory(Inventory(), sio)
768
empty_inv = sio.getvalue()
770
bzrlib.weavefile.write_weave_v5(Weave(), sio)
771
empty_weave = sio.getvalue()
773
dirs = [[], 'revision-store', 'weaves']
775
"This is a Bazaar-NG control directory.\n"
776
"Do not change any files in this directory.\n"),
777
('branch-format', BZR_BRANCH_FORMAT_6),
778
('revision-history', ''),
781
('pending-merges', ''),
782
('inventory', empty_inv),
783
('inventory.weave', empty_weave),
784
('ancestry.weave', empty_weave)
786
cfn = self._rel_controlfilename
787
self._transport.mkdir_multi([cfn(d) for d in dirs])
788
self.put_controlfiles(files)
789
mutter('created control directory in ' + self._transport.base)
791
def _check_format(self, relax_version_check):
792
"""Check this branch format is supported.
794
The format level is stored, as an integer, in
795
self._branch_format for code that needs to check it later.
797
In the future, we might need different in-memory Branch
798
classes to support downlevel branches. But not yet.
992
return self.control_files._transport.abspath(name)
994
def _check_format(self, format):
995
"""Identify the branch format if needed.
997
The format is stored as a reference to the format object in
998
self._format for code that needs to check it later.
1000
The format parameter is either None or the branch format class
1001
used to open this branch.
1003
FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
801
fmt = self.controlfile('branch-format', 'r').read()
803
raise NotBranchError(path=self.base)
804
mutter("got branch format %r", fmt)
805
if fmt == BZR_BRANCH_FORMAT_6:
806
self._branch_format = 6
807
elif fmt == BZR_BRANCH_FORMAT_5:
808
self._branch_format = 5
809
elif fmt == BZR_BRANCH_FORMAT_4:
810
self._branch_format = 4
812
if (not relax_version_check
813
and self._branch_format not in (5, 6)):
814
raise errors.UnsupportedFormatError(
815
'sorry, branch format %r not supported' % fmt,
816
['use a different bzr version',
817
'or remove the .bzr directory'
818
' and "bzr init" again'])
1006
format = BranchFormat.find_format(self.bzrdir)
1007
self._format = format
1008
mutter("got branch format %s", self._format)
820
1010
@needs_read_lock
821
1011
def get_root_id(self):
822
1012
"""See Branch.get_root_id."""
823
inv = self.get_inventory(self.last_revision())
824
return inv.root.file_id
1013
tree = self.repository.revision_tree(self.last_revision())
1014
return tree.inventory.root.file_id
1016
def is_locked(self):
1017
return self.control_files.is_locked()
1019
def lock_write(self):
1020
self.repository.lock_write()
1022
self.control_files.lock_write()
1024
self.repository.unlock()
1027
def lock_read(self):
1028
self.repository.lock_read()
1030
self.control_files.lock_read()
1032
self.repository.unlock()
1036
# TODO: test for failed two phase locks. This is known broken.
1038
self.control_files.unlock()
1040
self.repository.unlock()
1042
def peek_lock_mode(self):
1043
if self.control_files._lock_count == 0:
1046
return self.control_files._lock_mode
1048
def get_physical_lock_status(self):
1049
return self.control_files.get_physical_lock_status()
826
1051
@needs_read_lock
827
1052
def print_file(self, file, revision_id):
828
1053
"""See Branch.print_file."""
829
tree = self.revision_tree(revision_id)
830
# use inventory as it was in that revision
831
file_id = tree.inventory.path2id(file)
834
revno = self.revision_id_to_revno(revision_id)
835
except errors.NoSuchRevision:
836
# TODO: This should not be BzrError,
837
# but NoSuchFile doesn't fit either
838
raise BzrError('%r is not present in revision %s'
839
% (file, revision_id))
841
raise BzrError('%r is not present in revision %s'
843
tree.print_file(file_id)
1054
return self.repository.print_file(file, revision_id)
845
1056
@needs_write_lock
846
1057
def append_revision(self, *revision_ids):
854
1065
@needs_write_lock
855
1066
def set_revision_history(self, rev_history):
856
1067
"""See Branch.set_revision_history."""
857
old_revision = self.last_revision()
858
new_revision = rev_history[-1]
859
self.put_controlfile('revision-history', '\n'.join(rev_history))
861
self.working_tree().set_last_revision(new_revision, old_revision)
862
except NoWorkingTree:
863
mutter('Unable to set_last_revision without a working tree.')
865
def has_revision(self, revision_id):
866
"""See Branch.has_revision."""
867
return (revision_id is None
868
or self.revision_store.has_id(revision_id))
871
def _get_revision_xml_file(self, revision_id):
872
if not revision_id or not isinstance(revision_id, basestring):
873
raise InvalidRevisionId(revision_id=revision_id, branch=self)
875
return self.revision_store.get(revision_id)
876
except (IndexError, KeyError):
877
raise bzrlib.errors.NoSuchRevision(self, revision_id)
879
def get_revision_xml(self, revision_id):
880
"""See Branch.get_revision_xml."""
881
return self._get_revision_xml_file(revision_id).read()
883
def get_revision(self, revision_id):
884
"""See Branch.get_revision."""
885
xml_file = self._get_revision_xml_file(revision_id)
888
r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
889
except SyntaxError, e:
890
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
894
assert r.revision_id == revision_id
897
def get_revision_sha1(self, revision_id):
898
"""See Branch.get_revision_sha1."""
899
# In the future, revision entries will be signed. At that
900
# point, it is probably best *not* to include the signature
901
# in the revision hash. Because that lets you re-sign
902
# the revision, (add signatures/remove signatures) and still
903
# have all hash pointers stay consistent.
904
# But for now, just hash the contents.
905
return bzrlib.osutils.sha_file(self.get_revision_xml_file(revision_id))
907
def get_ancestry(self, revision_id):
908
"""See Branch.get_ancestry."""
909
if revision_id is None:
911
w = self._get_inventory_weave()
912
return [None] + map(w.idx_to_name,
913
w.inclusions([w.lookup(revision_id)]))
915
def _get_inventory_weave(self):
916
return self.control_weaves.get_weave('inventory',
917
self.get_transaction())
919
def get_inventory(self, revision_id):
920
"""See Branch.get_inventory."""
921
xml = self.get_inventory_xml(revision_id)
922
return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
924
def get_inventory_xml(self, revision_id):
925
"""See Branch.get_inventory_xml."""
927
assert isinstance(revision_id, basestring), type(revision_id)
928
iw = self._get_inventory_weave()
929
return iw.get_text(iw.lookup(revision_id))
931
raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
933
def get_inventory_sha1(self, revision_id):
934
"""See Branch.get_inventory_sha1."""
935
return self.get_revision(revision_id).inventory_sha1
937
def get_revision_inventory(self, revision_id):
938
"""See Branch.get_revision_inventory."""
939
# TODO: Unify this with get_inventory()
940
# bzr 0.0.6 and later imposes the constraint that the inventory_id
941
# must be the same as its revision, so this is trivial.
942
if revision_id == None:
943
# This does not make sense: if there is no revision,
944
# then it is the current tree inventory surely ?!
945
# and thus get_root_id() is something that looks at the last
946
# commit on the branch, and the get_root_id is an inventory check.
947
raise NotImplementedError
948
# return Inventory(self.get_root_id())
1068
self.control_files.put_utf8(
1069
'revision-history', '\n'.join(rev_history))
1070
transaction = self.get_transaction()
1071
history = transaction.map.find_revision_history()
1072
if history is not None:
1073
# update the revision history in the identity map.
1074
history[:] = list(rev_history)
1075
# this call is disabled because revision_history is
1076
# not really an object yet, and the transaction is for objects.
1077
# transaction.register_dirty(history)
950
return self.get_inventory(revision_id)
1079
transaction.map.add_revision_history(rev_history)
1080
# this call is disabled because revision_history is
1081
# not really an object yet, and the transaction is for objects.
1082
# transaction.register_clean(history)
952
1084
@needs_read_lock
953
1085
def revision_history(self):
955
1087
transaction = self.get_transaction()
956
1088
history = transaction.map.find_revision_history()
957
1089
if history is not None:
958
mutter("cache hit for revision-history in %s", self)
1090
# mutter("cache hit for revision-history in %s", self)
959
1091
return list(history)
960
history = [l.rstrip('\r\n') for l in
961
self.controlfile('revision-history', 'r').readlines()]
1092
decode_utf8 = cache_utf8.decode
1093
history = [decode_utf8(l.rstrip('\r\n')) for l in
1094
self.control_files.get('revision-history').readlines()]
962
1095
transaction.map.add_revision_history(history)
963
1096
# this call is disabled because revision_history is
964
1097
# not really an object yet, and the transaction is for objects.
965
1098
# transaction.register_clean(history, precious=True)
966
1099
return list(history)
1102
def generate_revision_history(self, revision_id, last_rev=None,
1104
"""Create a new revision history that will finish with revision_id.
1106
:param revision_id: the new tip to use.
1107
:param last_rev: The previous last_revision. If not None, then this
1108
must be a ancestory of revision_id, or DivergedBranches is raised.
1109
:param other_branch: The other branch that DivergedBranches should
1110
raise with respect to.
1112
# stop_revision must be a descendant of last_revision
1113
stop_graph = self.repository.get_revision_graph(revision_id)
1114
if last_rev is not None and last_rev not in stop_graph:
1115
# our previous tip is not merged into stop_revision
1116
raise errors.DivergedBranches(self, other_branch)
1117
# make a new revision history from the graph
1118
current_rev_id = revision_id
1120
while current_rev_id not in (None, revision.NULL_REVISION):
1121
new_history.append(current_rev_id)
1122
current_rev_id_parents = stop_graph[current_rev_id]
1124
current_rev_id = current_rev_id_parents[0]
1126
current_rev_id = None
1127
new_history.reverse()
1128
self.set_revision_history(new_history)
968
1131
def update_revisions(self, other, stop_revision=None):
969
1132
"""See Branch.update_revisions."""
970
from bzrlib.fetch import greedy_fetch
971
if stop_revision is None:
972
stop_revision = other.last_revision()
973
### Should this be checking is_ancestor instead of revision_history?
974
if (stop_revision is not None and
975
stop_revision in self.revision_history()):
977
greedy_fetch(to_branch=self, from_branch=other,
978
revision=stop_revision)
979
pullable_revs = self.pullable_revisions(other, stop_revision)
980
if len(pullable_revs) > 0:
981
self.append_revision(*pullable_revs)
983
def pullable_revisions(self, other, stop_revision):
984
"""See Branch.pullable_revisions."""
985
other_revno = other.revision_id_to_revno(stop_revision)
987
return self.missing_revisions(other, other_revno)
988
except DivergedBranches, e:
990
pullable_revs = get_intervening_revisions(self.last_revision(),
992
assert self.last_revision() not in pullable_revs
994
except bzrlib.errors.NotAncestor:
995
if is_ancestor(self.last_revision(), stop_revision, self):
1000
def revision_tree(self, revision_id):
1001
"""See Branch.revision_tree."""
1002
# TODO: refactor this to use an existing revision object
1003
# so we don't need to read it in twice.
1004
if revision_id == None or revision_id == NULL_REVISION:
1007
inv = self.get_revision_inventory(revision_id)
1008
return RevisionTree(self.weave_store, inv, revision_id)
1135
if stop_revision is None:
1136
stop_revision = other.last_revision()
1137
if stop_revision is None:
1138
# if there are no commits, we're done.
1140
# whats the current last revision, before we fetch [and change it
1142
last_rev = self.last_revision()
1143
# we fetch here regardless of whether we need to so that we pickup
1145
self.fetch(other, stop_revision)
1146
my_ancestry = self.repository.get_ancestry(last_rev)
1147
if stop_revision in my_ancestry:
1148
# last_revision is a descendant of stop_revision
1150
self.generate_revision_history(stop_revision, last_rev=last_rev,
1010
1155
def basis_tree(self):
1011
1156
"""See Branch.basis_tree."""
1013
revision_id = self.revision_history()[-1]
1014
xml = self.working_tree().read_basis_inventory(revision_id)
1015
inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
1016
return RevisionTree(self.weave_store, inv, revision_id)
1017
except (IndexError, NoSuchFile, NoWorkingTree), e:
1018
return self.revision_tree(self.last_revision())
1157
return self.repository.revision_tree(self.last_revision())
1159
@deprecated_method(zero_eight)
1020
1160
def working_tree(self):
1021
"""See Branch.working_tree."""
1022
from bzrlib.workingtree import WorkingTree
1023
if self._transport.base.find('://') != -1:
1161
"""Create a Working tree object for this branch."""
1163
from bzrlib.transport.local import LocalTransport
1164
if (self.base.find('://') != -1 or
1165
not isinstance(self._transport, LocalTransport)):
1024
1166
raise NoWorkingTree(self.base)
1025
return WorkingTree(self.base, branch=self)
1167
return self.bzrdir.open_workingtree()
1027
1169
@needs_write_lock
1028
def pull(self, source, overwrite=False):
1170
def pull(self, source, overwrite=False, stop_revision=None):
1029
1171
"""See Branch.pull."""
1030
1172
source.lock_read()
1032
1174
old_count = len(self.revision_history())
1034
self.update_revisions(source)
1176
self.update_revisions(source,stop_revision)
1035
1177
except DivergedBranches:
1036
1178
if not overwrite:
1045
1187
def get_parent(self):
1046
1188
"""See Branch.get_parent."""
1048
1190
_locs = ['parent', 'pull', 'x-pull']
1191
assert self.base[-1] == '/'
1049
1192
for l in _locs:
1051
return self.controlfile(l, 'r').read().strip('\n')
1194
parent = self.control_files.get(l).read().strip('\n')
1052
1195
except NoSuchFile:
1197
# This is an old-format absolute path to a local branch
1198
# turn it into a url
1199
if parent.startswith('/'):
1200
parent = urlutils.local_path_to_url(parent.decode('utf8'))
1202
return urlutils.join(self.base[:-1], parent)
1203
except errors.InvalidURLJoin, e:
1204
raise errors.InaccessibleParent(parent, self.base)
1056
1207
def get_push_location(self):
1057
1208
"""See Branch.get_push_location."""
1058
config = bzrlib.config.BranchConfig(self)
1059
push_loc = config.get_user_option('push_location')
1209
push_loc = self.get_config().get_user_option('push_location')
1060
1210
return push_loc
1062
1212
def set_push_location(self, location):
1063
1213
"""See Branch.set_push_location."""
1064
config = bzrlib.config.LocationConfig(self.base)
1065
config.set_user_option('push_location', location)
1214
self.get_config().set_user_option('push_location', location,
1067
1217
@needs_write_lock
1068
1218
def set_parent(self, url):
1069
1219
"""See Branch.set_parent."""
1070
1220
# TODO: Maybe delete old location files?
1071
from bzrlib.atomicfile import AtomicFile
1072
f = AtomicFile(self.controlfilename('parent'))
1221
# URLs should never be unicode, even on the local fs,
1222
# FIXUP this and get_parent in a future branch format bump:
1223
# read and rewrite the file, and have the new format code read
1224
# using .get not .get_utf8. RBC 20060125
1226
self.control_files._transport.delete('parent')
1228
if isinstance(url, unicode):
1230
url = url.encode('ascii')
1231
except UnicodeEncodeError:
1232
raise bzrlib.errors.InvalidURL(url,
1233
"Urls must be 7-bit ascii, "
1234
"use bzrlib.urlutils.escape")
1236
url = urlutils.relative_url(self.base, url)
1237
self.control_files.put('parent', StringIO(url + '\n'))
1239
@deprecated_function(zero_nine)
1079
1240
def tree_config(self):
1241
"""DEPRECATED; call get_config instead.
1242
TreeConfig has become part of BranchConfig."""
1080
1243
return TreeConfig(self)
1082
def sign_revision(self, revision_id, gpg_strategy):
1083
"""See Branch.sign_revision."""
1084
plaintext = Testament.from_revision(self, revision_id).as_short_text()
1085
self.store_revision_signature(gpg_strategy, plaintext, revision_id)
1088
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1089
"""See Branch.store_revision_signature."""
1090
self.revision_store.add(StringIO(gpg_strategy.sign(plaintext)),
1094
class ScratchBranch(BzrBranch):
1095
"""Special test class: a branch that cleans up after itself.
1097
>>> b = ScratchBranch()
1101
>>> b._transport.__del__()
1246
class BzrBranch5(BzrBranch):
1247
"""A format 5 branch. This supports new features over plan branches.
1249
It has support for a master_branch which is the data for bound branches.
1106
def __init__(self, files=[], dirs=[], transport=None):
1107
"""Make a test branch.
1109
This creates a temporary directory and runs init-tree in it.
1111
If any files are listed, they are created in the working copy.
1113
if transport is None:
1114
transport = bzrlib.transport.local.ScratchTransport()
1115
super(ScratchBranch, self).__init__(transport, init=True)
1257
super(BzrBranch5, self).__init__(_format=_format,
1258
_control_files=_control_files,
1260
_repository=_repository)
1263
def pull(self, source, overwrite=False, stop_revision=None):
1264
"""Updates branch.pull to be bound branch aware."""
1265
bound_location = self.get_bound_location()
1266
if source.base != bound_location:
1267
# not pulling from master, so we need to update master.
1268
master_branch = self.get_master_branch()
1270
master_branch.pull(source)
1271
source = master_branch
1272
return super(BzrBranch5, self).pull(source, overwrite, stop_revision)
1274
def get_bound_location(self):
1276
return self.control_files.get_utf8('bound').read()[:-1]
1277
except errors.NoSuchFile:
1281
def get_master_branch(self):
1282
"""Return the branch we are bound to.
1284
:return: Either a Branch, or None
1286
This could memoise the branch, but if thats done
1287
it must be revalidated on each new lock.
1288
So for now we just don't memoise it.
1289
# RBC 20060304 review this decision.
1291
bound_loc = self.get_bound_location()
1295
return Branch.open(bound_loc)
1296
except (errors.NotBranchError, errors.ConnectionError), e:
1297
raise errors.BoundBranchConnectionFailure(
1301
def set_bound_location(self, location):
1302
"""Set the target where this branch is bound to.
1304
:param location: URL to the target branch
1307
self.control_files.put_utf8('bound', location+'\n')
1117
super(ScratchBranch, self).__init__(transport)
1120
self._transport.mkdir(d)
1123
self._transport.put(f, 'content of %s' % f)
1128
>>> orig = ScratchBranch(files=["file1", "file2"])
1129
>>> clone = orig.clone()
1130
>>> if os.name != 'nt':
1131
... os.path.samefile(orig.base, clone.base)
1133
... orig.base == clone.base
1136
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1139
from shutil import copytree
1140
from tempfile import mkdtemp
1143
copytree(self.base, base, symlinks=True)
1144
return ScratchBranch(
1145
transport=bzrlib.transport.local.ScratchTransport(base))
1310
self.control_files._transport.delete('bound')
1316
def bind(self, other):
1317
"""Bind the local branch the other branch.
1319
:param other: The branch to bind to
1322
# TODO: jam 20051230 Consider checking if the target is bound
1323
# It is debatable whether you should be able to bind to
1324
# a branch which is itself bound.
1325
# Committing is obviously forbidden,
1326
# but binding itself may not be.
1327
# Since we *have* to check at commit time, we don't
1328
# *need* to check here
1331
# we are now equal to or a suffix of other.
1333
# Since we have 'pulled' from the remote location,
1334
# now we should try to pull in the opposite direction
1335
# in case the local tree has more revisions than the
1337
# There may be a different check you could do here
1338
# rather than actually trying to install revisions remotely.
1339
# TODO: capture an exception which indicates the remote branch
1341
# If it is up-to-date, this probably should not be a failure
1343
# lock other for write so the revision-history syncing cannot race
1347
# if this does not error, other now has the same last rev we do
1348
# it can only error if the pull from other was concurrent with
1349
# a commit to other from someone else.
1351
# until we ditch revision-history, we need to sync them up:
1352
self.set_revision_history(other.revision_history())
1353
# now other and self are up to date with each other and have the
1354
# same revision-history.
1358
self.set_bound_location(other.base)
1362
"""If bound, unbind"""
1363
return self.set_bound_location(None)
1367
"""Synchronise this branch with the master branch if any.
1369
:return: None or the last_revision that was pivoted out during the
1372
master = self.get_master_branch()
1373
if master is not None:
1374
old_tip = self.last_revision()
1375
self.pull(master, overwrite=True)
1376
if old_tip in self.repository.get_ancestry(self.last_revision()):
1382
class BranchTestProviderAdapter(object):
1383
"""A tool to generate a suite testing multiple branch formats at once.
1385
This is done by copying the test once for each transport and injecting
1386
the transport_server, transport_readonly_server, and branch_format
1387
classes into each copy. Each copy is also given a new id() to make it
1391
def __init__(self, transport_server, transport_readonly_server, formats):
1392
self._transport_server = transport_server
1393
self._transport_readonly_server = transport_readonly_server
1394
self._formats = formats
1396
def adapt(self, test):
1397
result = TestSuite()
1398
for branch_format, bzrdir_format in self._formats:
1399
new_test = deepcopy(test)
1400
new_test.transport_server = self._transport_server
1401
new_test.transport_readonly_server = self._transport_readonly_server
1402
new_test.bzrdir_format = bzrdir_format
1403
new_test.branch_format = branch_format
1404
def make_new_test_id():
1405
new_id = "%s(%s)" % (new_test.id(), branch_format.__class__.__name__)
1406
return lambda: new_id
1407
new_test.id = make_new_test_id()
1408
result.addTest(new_test)
1412
class BranchCheckResult(object):
1413
"""Results of checking branch consistency.
1418
def __init__(self, branch):
1419
self.branch = branch
1421
def report_results(self, verbose):
1422
"""Report the check results via trace.note.
1424
:param verbose: Requests more detailed display of what was checked,
1427
note('checked branch %s format %s',
1429
self.branch._format)
1148
1432
######################################################################
1152
def is_control_file(filename):
1153
## FIXME: better check
1154
filename = os.path.normpath(filename)
1155
while filename != '':
1156
head, tail = os.path.split(filename)
1157
## mutter('check %r for control file' % ((head, tail), ))
1158
if tail == bzrlib.BZRDIR:
1160
if filename == head:
1436
@deprecated_function(zero_eight)
1437
def is_control_file(*args, **kwargs):
1438
"""See bzrlib.workingtree.is_control_file."""
1439
return bzrlib.workingtree.is_control_file(*args, **kwargs)
added
removed
bzrlib/branch.py
