666
481
if revno < 1 or revno > self.revno():
667
482
raise InvalidRevisionNumber(revno)
670
def clone(self, to_bzrdir, revision_id=None):
671
"""Clone this branch into to_bzrdir preserving all semantic values.
673
revision_id: if not None, the revision history in the new branch will
674
be truncated to end with revision_id.
676
result = self._format.initialize(to_bzrdir)
677
self.copy_content_into(result, revision_id=revision_id)
681
def sprout(self, to_bzrdir, revision_id=None):
682
"""Create a new line of development from the branch, into to_bzrdir.
684
revision_id: if not None, the revision history in the new branch will
685
be truncated to end with revision_id.
687
result = self._format.initialize(to_bzrdir)
688
self.copy_content_into(result, revision_id=revision_id)
689
result.set_parent(self.bzrdir.root_transport.base)
692
def _synchronize_history(self, destination, revision_id):
693
"""Synchronize last revision and revision history between branches.
695
This version is most efficient when the destination is also a
696
BzrBranch5, but works for BzrBranch6 as long as the revision
697
history is the true lefthand parent history, and all of the revisions
698
are in the destination's repository. If not, set_revision_history
701
:param destination: The branch to copy the history into
702
:param revision_id: The revision-id to truncate history at. May
703
be None to copy complete history.
705
new_history = self.revision_history()
706
if revision_id is not None:
707
revision_id = osutils.safe_revision_id(revision_id)
709
new_history = new_history[:new_history.index(revision_id) + 1]
711
rev = self.repository.get_revision(revision_id)
712
new_history = rev.get_history(self.repository)[1:]
713
destination.set_revision_history(new_history)
716
def copy_content_into(self, destination, revision_id=None):
717
"""Copy the content of self into destination.
719
revision_id: if not None, the revision history in the new branch will
720
be truncated to end with revision_id.
722
self._synchronize_history(destination, revision_id)
724
parent = self.get_parent()
725
except errors.InaccessibleParent, e:
726
mutter('parent was not accessible to copy: %s', e)
729
destination.set_parent(parent)
730
self.tags.merge_to(destination.tags)
734
"""Check consistency of the branch.
736
In particular this checks that revisions given in the revision-history
737
do actually match up in the revision graph, and that they're all
738
present in the repository.
740
Callers will typically also want to check the repository.
742
:return: A BranchCheckResult.
744
mainline_parent_id = None
745
for revision_id in self.revision_history():
747
revision = self.repository.get_revision(revision_id)
748
except errors.NoSuchRevision, e:
749
raise errors.BzrCheckError("mainline revision {%s} not in repository"
751
# In general the first entry on the revision history has no parents.
752
# But it's not illegal for it to have parents listed; this can happen
753
# in imports from Arch when the parents weren't reachable.
754
if mainline_parent_id is not None:
755
if mainline_parent_id not in revision.parent_ids:
756
raise errors.BzrCheckError("previous revision {%s} not listed among "
758
% (mainline_parent_id, revision_id))
759
mainline_parent_id = revision_id
760
return BranchCheckResult(self)
762
def _get_checkout_format(self):
763
"""Return the most suitable metadir for a checkout of this branch.
764
Weaves are used if this branch's repository uses weaves.
766
if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):
767
from bzrlib.repofmt import weaverepo
768
format = bzrdir.BzrDirMetaFormat1()
769
format.repository_format = weaverepo.RepositoryFormat7()
771
format = self.repository.bzrdir.checkout_metadir()
772
format.set_branch_format(self._format)
775
def create_checkout(self, to_location, revision_id=None,
777
"""Create a checkout of a branch.
779
:param to_location: The url to produce the checkout at
780
:param revision_id: The revision to check out
781
:param lightweight: If True, produce a lightweight checkout, otherwise,
782
produce a bound branch (heavyweight checkout)
783
:return: The tree of the created checkout
785
t = transport.get_transport(to_location)
788
format = self._get_checkout_format()
789
checkout = format.initialize_on_transport(t)
790
BranchReferenceFormat().initialize(checkout, self)
792
format = self._get_checkout_format()
793
checkout_branch = bzrdir.BzrDir.create_branch_convenience(
794
to_location, force_new_tree=False, format=format)
795
checkout = checkout_branch.bzrdir
796
checkout_branch.bind(self)
797
# pull up to the specified revision_id to set the initial
798
# branch tip correctly, and seed it with history.
799
checkout_branch.pull(self, stop_revision=revision_id)
800
tree = checkout.create_workingtree(revision_id)
801
basis_tree = tree.basis_tree()
802
basis_tree.lock_read()
804
for path, file_id in basis_tree.iter_references():
805
reference_parent = self.reference_parent(file_id, path)
806
reference_parent.create_checkout(tree.abspath(path),
807
basis_tree.get_reference_revision(file_id, path),
813
def reference_parent(self, file_id, path):
814
"""Return the parent branch for a tree-reference file_id
815
:param file_id: The file_id of the tree reference
816
:param path: The path of the file_id in the tree
817
:return: A branch associated with the file_id
819
# FIXME should provide multiple branches, based on config
820
return Branch.open(self.bzrdir.root_transport.clone(path).base)
822
def supports_tags(self):
823
return self._format.supports_tags()
826
class BranchFormat(object):
827
"""An encapsulation of the initialization and open routines for a format.
829
Formats provide three things:
830
* An initialization routine,
834
Formats are placed in an dict by their format string for reference
835
during branch opening. Its not required that these be instances, they
836
can be classes themselves with class methods - it simply depends on
837
whether state is needed for a given format or not.
839
Once a format is deprecated, just deprecate the initialize and open
840
methods on the format class. Do not deprecate the object, as the
841
object will be created every time regardless.
844
_default_format = None
845
"""The default format used for new branches."""
848
"""The known formats."""
851
def find_format(klass, a_bzrdir):
852
"""Return the format for the branch object in a_bzrdir."""
854
transport = a_bzrdir.get_branch_transport(None)
855
format_string = transport.get("format").read()
856
return klass._formats[format_string]
858
raise NotBranchError(path=transport.base)
860
raise errors.UnknownFormatError(format=format_string)
863
def get_default_format(klass):
864
"""Return the current default format."""
865
return klass._default_format
867
def get_reference(self, a_bzrdir):
868
"""Get the target reference of the branch in a_bzrdir.
870
format probing must have been completed before calling
871
this method - it is assumed that the format of the branch
872
in a_bzrdir is correct.
874
:param a_bzrdir: The bzrdir to get the branch data from.
875
:return: None if the branch is not a reference branch.
879
def get_format_string(self):
880
"""Return the ASCII format string that identifies this format."""
881
raise NotImplementedError(self.get_format_string)
883
def get_format_description(self):
884
"""Return the short format description for this format."""
885
raise NotImplementedError(self.get_format_description)
887
def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
889
"""Initialize a branch in a bzrdir, with specified files
891
:param a_bzrdir: The bzrdir to initialize the branch in
892
:param utf8_files: The files to create as a list of
893
(filename, content) tuples
894
:param set_format: If True, set the format with
895
self.get_format_string. (BzrBranch4 has its format set
897
:return: a branch in this format
899
mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
900
branch_transport = a_bzrdir.get_branch_transport(self)
902
'metadir': ('lock', lockdir.LockDir),
903
'branch4': ('branch-lock', lockable_files.TransportLock),
905
lock_name, lock_class = lock_map[lock_type]
906
control_files = lockable_files.LockableFiles(branch_transport,
907
lock_name, lock_class)
908
control_files.create_lock()
909
control_files.lock_write()
911
control_files.put_utf8('format', self.get_format_string())
913
for file, content in utf8_files:
914
control_files.put_utf8(file, content)
916
control_files.unlock()
917
return self.open(a_bzrdir, _found=True)
919
def initialize(self, a_bzrdir):
920
"""Create a branch of this format in a_bzrdir."""
921
raise NotImplementedError(self.initialize)
923
def is_supported(self):
924
"""Is this format supported?
926
Supported formats can be initialized and opened.
927
Unsupported formats may not support initialization or committing or
928
some other features depending on the reason for not being supported.
932
def open(self, a_bzrdir, _found=False):
933
"""Return the branch object for a_bzrdir
935
_found is a private parameter, do not use it. It is used to indicate
936
if format probing has already be done.
938
raise NotImplementedError(self.open)
941
def register_format(klass, format):
942
klass._formats[format.get_format_string()] = format
945
def set_default_format(klass, format):
946
klass._default_format = format
949
def unregister_format(klass, format):
950
assert klass._formats[format.get_format_string()] is format
951
del klass._formats[format.get_format_string()]
954
return self.get_format_string().rstrip()
956
def supports_tags(self):
957
"""True if this format supports tags stored in the branch"""
958
return False # by default
960
# XXX: Probably doesn't really belong here -- mbp 20070212
961
def _initialize_control_files(self, a_bzrdir, utf8_files, lock_filename,
963
branch_transport = a_bzrdir.get_branch_transport(self)
964
control_files = lockable_files.LockableFiles(branch_transport,
965
lock_filename, lock_class)
966
control_files.create_lock()
967
control_files.lock_write()
969
for filename, content in utf8_files:
970
control_files.put_utf8(filename, content)
972
control_files.unlock()
975
class BranchHooks(Hooks):
976
"""A dictionary mapping hook name to a list of callables for branch hooks.
978
e.g. ['set_rh'] Is the list of items to be called when the
979
set_revision_history function is invoked.
983
"""Create the default hooks.
985
These are all empty initially, because by default nothing should get
989
# Introduced in 0.15:
990
# invoked whenever the revision history has been set
991
# with set_revision_history. The api signature is
992
# (branch, revision_history), and the branch will
995
# invoked after a push operation completes.
996
# the api signature is
998
# containing the members
999
# (source, local, master, old_revno, old_revid, new_revno, new_revid)
1000
# where local is the local target branch or None, master is the target
1001
# master branch, and the rest should be self explanatory. The source
1002
# is read locked and the target branches write locked. Source will
1003
# be the local low-latency branch.
1004
self['post_push'] = []
1005
# invoked after a pull operation completes.
1006
# the api signature is
1008
# containing the members
1009
# (source, local, master, old_revno, old_revid, new_revno, new_revid)
1010
# where local is the local branch or None, master is the target
1011
# master branch, and the rest should be self explanatory. The source
1012
# is read locked and the target branches write locked. The local
1013
# branch is the low-latency branch.
1014
self['post_pull'] = []
1015
# invoked after a commit operation completes.
1016
# the api signature is
1017
# (local, master, old_revno, old_revid, new_revno, new_revid)
1018
# old_revid is NULL_REVISION for the first commit to a branch.
1019
self['post_commit'] = []
1020
# invoked after a uncommit operation completes.
1021
# the api signature is
1022
# (local, master, old_revno, old_revid, new_revno, new_revid) where
1023
# local is the local branch or None, master is the target branch,
1024
# and an empty branch recieves new_revno of 0, new_revid of None.
1025
self['post_uncommit'] = []
1028
# install the default hooks into the Branch class.
1029
Branch.hooks = BranchHooks()
1032
class BzrBranchFormat4(BranchFormat):
1033
"""Bzr branch format 4.
1036
- a revision-history file.
1037
- a branch-lock lock file [ to be shared with the bzrdir ]
1040
def get_format_description(self):
1041
"""See BranchFormat.get_format_description()."""
1042
return "Branch format 4"
1044
def initialize(self, a_bzrdir):
1045
"""Create a branch of this format in a_bzrdir."""
1046
utf8_files = [('revision-history', ''),
1047
('branch-name', ''),
1049
return self._initialize_helper(a_bzrdir, utf8_files,
1050
lock_type='branch4', set_format=False)
1053
super(BzrBranchFormat4, self).__init__()
1054
self._matchingbzrdir = bzrdir.BzrDirFormat6()
1056
def open(self, a_bzrdir, _found=False):
1057
"""Return the branch object for a_bzrdir
1059
_found is a private parameter, do not use it. It is used to indicate
1060
if format probing has already be done.
1063
# we are being called directly and must probe.
1064
raise NotImplementedError
1065
return BzrBranch(_format=self,
1066
_control_files=a_bzrdir._control_files,
1068
_repository=a_bzrdir.open_repository())
1071
return "Bazaar-NG branch format 4"
1074
class BzrBranchFormat5(BranchFormat):
1075
"""Bzr branch format 5.
1078
- a revision-history file.
1080
- a lock dir guarding the branch itself
1081
- all of this stored in a branch/ subdirectory
1082
- works with shared repositories.
1084
This format is new in bzr 0.8.
1087
def get_format_string(self):
1088
"""See BranchFormat.get_format_string()."""
1089
return "Bazaar-NG branch format 5\n"
1091
def get_format_description(self):
1092
"""See BranchFormat.get_format_description()."""
1093
return "Branch format 5"
1095
def initialize(self, a_bzrdir):
1096
"""Create a branch of this format in a_bzrdir."""
1097
utf8_files = [('revision-history', ''),
1098
('branch-name', ''),
1100
return self._initialize_helper(a_bzrdir, utf8_files)
1103
super(BzrBranchFormat5, self).__init__()
1104
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1106
def open(self, a_bzrdir, _found=False):
1107
"""Return the branch object for a_bzrdir
1109
_found is a private parameter, do not use it. It is used to indicate
1110
if format probing has already be done.
1113
format = BranchFormat.find_format(a_bzrdir)
1114
assert format.__class__ == self.__class__
1116
transport = a_bzrdir.get_branch_transport(None)
1117
control_files = lockable_files.LockableFiles(transport, 'lock',
1119
return BzrBranch5(_format=self,
1120
_control_files=control_files,
1122
_repository=a_bzrdir.find_repository())
1124
raise NotBranchError(path=transport.base)
1127
class BzrBranchFormat6(BzrBranchFormat5):
1128
"""Branch format with last-revision
1130
Unlike previous formats, this has no explicit revision history. Instead,
1131
this just stores the last-revision, and the left-hand history leading
1132
up to there is the history.
1134
This format was introduced in bzr 0.15
1137
def get_format_string(self):
1138
"""See BranchFormat.get_format_string()."""
1139
return "Bazaar Branch Format 6 (bzr 0.15)\n"
1141
def get_format_description(self):
1142
"""See BranchFormat.get_format_description()."""
1143
return "Branch format 6"
1145
def initialize(self, a_bzrdir):
1146
"""Create a branch of this format in a_bzrdir."""
1147
utf8_files = [('last-revision', '0 null:\n'),
1148
('branch-name', ''),
1149
('branch.conf', ''),
1152
return self._initialize_helper(a_bzrdir, utf8_files)
1154
def open(self, a_bzrdir, _found=False):
1155
"""Return the branch object for a_bzrdir
1157
_found is a private parameter, do not use it. It is used to indicate
1158
if format probing has already be done.
1161
format = BranchFormat.find_format(a_bzrdir)
1162
assert format.__class__ == self.__class__
1163
transport = a_bzrdir.get_branch_transport(None)
1164
control_files = lockable_files.LockableFiles(transport, 'lock',
1166
return BzrBranch6(_format=self,
1167
_control_files=control_files,
1169
_repository=a_bzrdir.find_repository())
1171
def supports_tags(self):
1175
class BranchReferenceFormat(BranchFormat):
1176
"""Bzr branch reference format.
1178
Branch references are used in implementing checkouts, they
1179
act as an alias to the real branch which is at some other url.
1186
def get_format_string(self):
1187
"""See BranchFormat.get_format_string()."""
1188
return "Bazaar-NG Branch Reference Format 1\n"
1190
def get_format_description(self):
1191
"""See BranchFormat.get_format_description()."""
1192
return "Checkout reference format 1"
1194
def get_reference(self, a_bzrdir):
1195
"""See BranchFormat.get_reference()."""
1196
transport = a_bzrdir.get_branch_transport(None)
1197
return transport.get('location').read()
1199
def initialize(self, a_bzrdir, target_branch=None):
1200
"""Create a branch of this format in a_bzrdir."""
1201
if target_branch is None:
1202
# this format does not implement branch itself, thus the implicit
1203
# creation contract must see it as uninitializable
1204
raise errors.UninitializableFormat(self)
1205
mutter('creating branch reference in %s', a_bzrdir.transport.base)
1206
branch_transport = a_bzrdir.get_branch_transport(self)
1207
branch_transport.put_bytes('location',
1208
target_branch.bzrdir.root_transport.base)
1209
branch_transport.put_bytes('format', self.get_format_string())
1210
return self.open(a_bzrdir, _found=True)
1213
super(BranchReferenceFormat, self).__init__()
1214
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1216
def _make_reference_clone_function(format, a_branch):
1217
"""Create a clone() routine for a branch dynamically."""
1218
def clone(to_bzrdir, revision_id=None):
1219
"""See Branch.clone()."""
1220
return format.initialize(to_bzrdir, a_branch)
1221
# cannot obey revision_id limits when cloning a reference ...
1222
# FIXME RBC 20060210 either nuke revision_id for clone, or
1223
# emit some sort of warning/error to the caller ?!
1226
def open(self, a_bzrdir, _found=False, location=None):
1227
"""Return the branch that the branch reference in a_bzrdir points at.
1229
_found is a private parameter, do not use it. It is used to indicate
1230
if format probing has already be done.
1233
format = BranchFormat.find_format(a_bzrdir)
1234
assert format.__class__ == self.__class__
1235
if location is None:
1236
location = self.get_reference(a_bzrdir)
1237
real_bzrdir = bzrdir.BzrDir.open(location)
1238
result = real_bzrdir.open_branch()
1239
# this changes the behaviour of result.clone to create a new reference
1240
# rather than a copy of the content of the branch.
1241
# I did not use a proxy object because that needs much more extensive
1242
# testing, and we are only changing one behaviour at the moment.
1243
# If we decide to alter more behaviours - i.e. the implicit nickname
1244
# then this should be refactored to introduce a tested proxy branch
1245
# and a subclass of that for use in overriding clone() and ....
1247
result.clone = self._make_reference_clone_function(result)
1251
# formats which have no format string are not discoverable
1252
# and not independently creatable, so are not registered.
1253
__default_format = BzrBranchFormat5()
1254
BranchFormat.register_format(__default_format)
1255
BranchFormat.register_format(BranchReferenceFormat())
1256
BranchFormat.register_format(BzrBranchFormat6())
1257
BranchFormat.set_default_format(__default_format)
1258
_legacy_formats = [BzrBranchFormat4(),
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')
1261
490
class BzrBranch(Branch):
1262
491
"""A branch stored in the actual filesystem.
1264
493
Note that it's "local" in the context of the filesystem; it doesn't
1265
494
really matter if it's on an nfs/smb/afs/coda/... share, as long as
1266
495
it's writable, and can be accessed via the normal filesystem API.
501
If _lock_mode is true, a positive count of the number of times the
505
Lock object from bzrlib.lock.
507
# We actually expect this class to be somewhat short-lived; part of its
508
# purpose is to try to isolate what bits of the branch logic are tied to
509
# filesystem access, so that in a later step, we can extricate them to
510
# a separarte ("storage") class.
514
_inventory_weave = None
1269
def __init__(self, _format=None,
1270
_control_files=None, a_bzrdir=None, _repository=None):
1271
"""Create new branch object at a particular location."""
1272
Branch.__init__(self)
1273
if a_bzrdir is None:
1274
raise ValueError('a_bzrdir must be supplied')
1276
self.bzrdir = a_bzrdir
1277
# self._transport used to point to the directory containing the
1278
# control directory, but was not used - now it's just the transport
1279
# for the branch control files. mbp 20070212
1280
self._base = self.bzrdir.transport.clone('..').base
1281
self._format = _format
1282
if _control_files is None:
1283
raise ValueError('BzrBranch _control_files is None')
1284
self.control_files = _control_files
1285
self._transport = _control_files._transport
1286
self.repository = _repository
516
# Map some sort of prefix into a namespace
517
# stuff like "revno:10", "revid:", etc.
518
# This should match a prefix with a function which accepts
519
REVISION_NAMESPACES = {}
521
def push_stores(self, branch_to):
522
"""See Branch.push_stores."""
523
if (self._branch_format != branch_to._branch_format
524
or self._branch_format != 4):
525
from bzrlib.fetch import greedy_fetch
526
mutter("falling back to fetch logic to push between %s(%s) and %s(%s)",
527
self, self._branch_format, branch_to, branch_to._branch_format)
528
greedy_fetch(to_branch=branch_to, from_branch=self,
529
revision=self.last_revision())
532
store_pairs = ((self.text_store, branch_to.text_store),
533
(self.inventory_store, branch_to.inventory_store),
534
(self.revision_store, branch_to.revision_store))
536
for from_store, to_store in store_pairs:
537
copy_all(from_store, to_store)
538
except UnlistableStore:
539
raise UnlistableBranch(from_store)
541
def __init__(self, transport, init=False,
542
relax_version_check=False):
543
"""Create new branch object at a particular location.
545
transport -- A Transport object, defining how to access files.
547
init -- If True, create new control files in a previously
548
unversioned directory. If False, the branch must already
551
relax_version_check -- If true, the usual check for the branch
552
version is not applied. This is intended only for
553
upgrade/recovery type use; it's not guaranteed that
554
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
1288
603
def __str__(self):
1289
return '%s(%r)' % (self.__class__.__name__, self.base)
604
return '%s(%r)' % (self.__class__.__name__, self._transport.base)
1291
606
__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
1293
628
def _get_base(self):
1294
"""Returns the directory containing the control directory."""
630
return self._transport.base
1297
633
base = property(_get_base, doc="The URL for the root of this branch.")
635
def _finish_transaction(self):
636
"""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
644
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):
652
"""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
1299
702
def abspath(self, name):
1300
703
"""See Branch.abspath."""
1301
return self.control_files._transport.abspath(name)
1304
@deprecated_method(zero_sixteen)
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.
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'])
1305
820
@needs_read_lock
1306
821
def get_root_id(self):
1307
822
"""See Branch.get_root_id."""
1308
tree = self.repository.revision_tree(self.last_revision())
1309
return tree.inventory.root.file_id
1311
def is_locked(self):
1312
return self.control_files.is_locked()
1314
def lock_write(self, token=None):
1315
repo_token = self.repository.lock_write()
1317
token = self.control_files.lock_write(token=token)
1319
self.repository.unlock()
1323
def lock_read(self):
1324
self.repository.lock_read()
1326
self.control_files.lock_read()
1328
self.repository.unlock()
1332
# TODO: test for failed two phase locks. This is known broken.
1334
self.control_files.unlock()
1336
self.repository.unlock()
1337
if not self.control_files.is_locked():
1338
# we just released the lock
1339
self._clear_cached_state()
1341
def peek_lock_mode(self):
1342
if self.control_files._lock_count == 0:
1345
return self.control_files._lock_mode
1347
def get_physical_lock_status(self):
1348
return self.control_files.get_physical_lock_status()
823
inv = self.get_inventory(self.last_revision())
824
return inv.root.file_id
1350
826
@needs_read_lock
1351
def print_file(self, file, revision_id):
827
def print_file(self, file, revno):
1352
828
"""See Branch.print_file."""
1353
return self.repository.print_file(file, revision_id)
829
tree = self.revision_tree(self.get_rev_id(revno))
830
# use inventory as it was in that revision
831
file_id = tree.inventory.path2id(file)
833
raise BzrError("%r is not present in revision %s" % (file, revno))
834
tree.print_file(file_id)
1355
836
@needs_write_lock
1356
837
def append_revision(self, *revision_ids):
1357
838
"""See Branch.append_revision."""
1358
revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
1359
839
for revision_id in revision_ids:
1360
_mod_revision.check_not_reserved_id(revision_id)
1361
840
mutter("add {%s} to revision-history" % revision_id)
1362
841
rev_history = self.revision_history()
1363
842
rev_history.extend(revision_ids)
1364
843
self.set_revision_history(rev_history)
1366
def _write_revision_history(self, history):
1367
"""Factored out of set_revision_history.
1369
This performs the actual writing to disk.
1370
It is intended to be called by BzrBranch5.set_revision_history."""
1371
self.control_files.put_bytes(
1372
'revision-history', '\n'.join(history))
1374
845
@needs_write_lock
1375
846
def set_revision_history(self, rev_history):
1376
847
"""See Branch.set_revision_history."""
1377
rev_history = [osutils.safe_revision_id(r) for r in rev_history]
1378
self._clear_cached_state()
1379
self._write_revision_history(rev_history)
1380
self._cache_revision_history(rev_history)
1381
for hook in Branch.hooks['set_rh']:
1382
hook(self, rev_history)
1385
def set_last_revision_info(self, revno, revision_id):
1386
revision_id = osutils.safe_revision_id(revision_id)
1387
history = self._lefthand_history(revision_id)
1388
assert len(history) == revno, '%d != %d' % (len(history), revno)
1389
self.set_revision_history(history)
1391
def _gen_revision_history(self):
1392
history = self.control_files.get('revision-history').read().split('\n')
1393
if history[-1:] == ['']:
1394
# There shouldn't be a trailing newline, but just in case.
1398
def _lefthand_history(self, revision_id, last_rev=None,
1400
# stop_revision must be a descendant of last_revision
1401
stop_graph = self.repository.get_revision_graph(revision_id)
1402
if last_rev is not None and last_rev not in stop_graph:
1403
# our previous tip is not merged into stop_revision
1404
raise errors.DivergedBranches(self, other_branch)
1405
# make a new revision history from the graph
1406
current_rev_id = revision_id
1408
while current_rev_id not in (None, _mod_revision.NULL_REVISION):
1409
new_history.append(current_rev_id)
1410
current_rev_id_parents = stop_graph[current_rev_id]
1412
current_rev_id = current_rev_id_parents[0]
1414
current_rev_id = None
1415
new_history.reverse()
1419
def generate_revision_history(self, revision_id, last_rev=None,
1421
"""Create a new revision history that will finish with revision_id.
1423
:param revision_id: the new tip to use.
1424
:param last_rev: The previous last_revision. If not None, then this
1425
must be a ancestory of revision_id, or DivergedBranches is raised.
1426
:param other_branch: The other branch that DivergedBranches should
1427
raise with respect to.
1429
revision_id = osutils.safe_revision_id(revision_id)
1430
self.set_revision_history(self._lefthand_history(revision_id,
1431
last_rev, other_branch))
848
old_revision = self.last_revision()
849
new_revision = rev_history[-1]
850
self.put_controlfile('revision-history', '\n'.join(rev_history))
851
self.working_tree().set_last_revision(new_revision, old_revision)
853
def has_revision(self, revision_id):
854
"""See Branch.has_revision."""
855
return (revision_id is None
856
or self.revision_store.has_id(revision_id))
859
def _get_revision_xml_file(self, revision_id):
860
if not revision_id or not isinstance(revision_id, basestring):
861
raise InvalidRevisionId(revision_id=revision_id, branch=self)
863
return self.revision_store.get(revision_id)
864
except (IndexError, KeyError):
865
raise bzrlib.errors.NoSuchRevision(self, revision_id)
867
def get_revision_xml(self, revision_id):
868
"""See Branch.get_revision_xml."""
869
return self._get_revision_xml_file(revision_id).read()
871
def get_revision(self, revision_id):
872
"""See Branch.get_revision."""
873
xml_file = self._get_revision_xml_file(revision_id)
876
r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
877
except SyntaxError, e:
878
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
882
assert r.revision_id == revision_id
885
def get_revision_sha1(self, revision_id):
886
"""See Branch.get_revision_sha1."""
887
# In the future, revision entries will be signed. At that
888
# point, it is probably best *not* to include the signature
889
# in the revision hash. Because that lets you re-sign
890
# the revision, (add signatures/remove signatures) and still
891
# have all hash pointers stay consistent.
892
# But for now, just hash the contents.
893
return bzrlib.osutils.sha_file(self.get_revision_xml_file(revision_id))
895
def get_ancestry(self, revision_id):
896
"""See Branch.get_ancestry."""
897
if revision_id is None:
899
w = self._get_inventory_weave()
900
return [None] + map(w.idx_to_name,
901
w.inclusions([w.lookup(revision_id)]))
903
def _get_inventory_weave(self):
904
return self.control_weaves.get_weave('inventory',
905
self.get_transaction())
907
def get_inventory(self, revision_id):
908
"""See Branch.get_inventory."""
909
xml = self.get_inventory_xml(revision_id)
910
return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
912
def get_inventory_xml(self, revision_id):
913
"""See Branch.get_inventory_xml."""
915
assert isinstance(revision_id, basestring), type(revision_id)
916
iw = self._get_inventory_weave()
917
return iw.get_text(iw.lookup(revision_id))
919
raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
921
def get_inventory_sha1(self, revision_id):
922
"""See Branch.get_inventory_sha1."""
923
return self.get_revision(revision_id).inventory_sha1
925
def get_revision_inventory(self, revision_id):
926
"""See Branch.get_revision_inventory."""
927
# TODO: Unify this with get_inventory()
928
# bzr 0.0.6 and later imposes the constraint that the inventory_id
929
# must be the same as its revision, so this is trivial.
930
if revision_id == None:
931
# This does not make sense: if there is no revision,
932
# then it is the current tree inventory surely ?!
933
# and thus get_root_id() is something that looks at the last
934
# commit on the branch, and the get_root_id is an inventory check.
935
raise NotImplementedError
936
# return Inventory(self.get_root_id())
938
return self.get_inventory(revision_id)
941
def revision_history(self):
942
"""See Branch.revision_history."""
943
transaction = self.get_transaction()
944
history = transaction.map.find_revision_history()
945
if history is not None:
946
mutter("cache hit for revision-history in %s", self)
948
history = [l.rstrip('\r\n') for l in
949
self.controlfile('revision-history', 'r').readlines()]
950
transaction.map.add_revision_history(history)
951
# this call is disabled because revision_history is
952
# not really an object yet, and the transaction is for objects.
953
# transaction.register_clean(history, precious=True)
1434
956
def update_revisions(self, other, stop_revision=None):
1435
957
"""See Branch.update_revisions."""
958
from bzrlib.fetch import greedy_fetch
959
if stop_revision is None:
960
stop_revision = other.last_revision()
961
### Should this be checking is_ancestor instead of revision_history?
962
if (stop_revision is not None and
963
stop_revision in self.revision_history()):
965
greedy_fetch(to_branch=self, from_branch=other,
966
revision=stop_revision)
967
pullable_revs = self.pullable_revisions(other, stop_revision)
968
if len(pullable_revs) > 0:
969
self.append_revision(*pullable_revs)
971
def pullable_revisions(self, other, stop_revision):
972
"""See Branch.pullable_revisions."""
973
other_revno = other.revision_id_to_revno(stop_revision)
1438
if stop_revision is None:
1439
stop_revision = other.last_revision()
1440
if stop_revision is None:
1441
# if there are no commits, we're done.
1444
stop_revision = osutils.safe_revision_id(stop_revision)
1445
# whats the current last revision, before we fetch [and change it
1447
last_rev = self.last_revision()
1448
# we fetch here regardless of whether we need to so that we pickup
1450
self.fetch(other, stop_revision)
1451
my_ancestry = self.repository.get_ancestry(last_rev)
1452
if stop_revision in my_ancestry:
1453
# last_revision is a descendant of stop_revision
1455
self.generate_revision_history(stop_revision, last_rev=last_rev,
975
return self.missing_revisions(other, other_revno)
976
except DivergedBranches, e:
978
pullable_revs = get_intervening_revisions(self.last_revision(),
980
assert self.last_revision() not in pullable_revs
982
except bzrlib.errors.NotAncestor:
983
if is_ancestor(self.last_revision(), stop_revision, self):
988
def revision_tree(self, revision_id):
989
"""See Branch.revision_tree."""
990
# TODO: refactor this to use an existing revision object
991
# so we don't need to read it in twice.
992
if revision_id == None or revision_id == NULL_REVISION:
995
inv = self.get_revision_inventory(revision_id)
996
return RevisionTree(self.weave_store, inv, revision_id)
1460
998
def basis_tree(self):
1461
999
"""See Branch.basis_tree."""
1462
return self.repository.revision_tree(self.last_revision())
1001
revision_id = self.revision_history()[-1]
1002
xml = self.working_tree().read_basis_inventory(revision_id)
1003
inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
1004
return RevisionTree(self.weave_store, inv, revision_id)
1005
except (IndexError, NoSuchFile), e:
1006
return self.revision_tree(self.last_revision())
1464
@deprecated_method(zero_eight)
1465
1008
def working_tree(self):
1466
"""Create a Working tree object for this branch."""
1468
from bzrlib.transport.local import LocalTransport
1469
if (self.base.find('://') != -1 or
1470
not isinstance(self._transport, LocalTransport)):
1009
"""See Branch.working_tree."""
1010
from bzrlib.workingtree import WorkingTree
1011
if self._transport.base.find('://') != -1:
1471
1012
raise NoWorkingTree(self.base)
1472
return self.bzrdir.open_workingtree()
1013
return WorkingTree(self.base, branch=self)
1474
1015
@needs_write_lock
1475
def pull(self, source, overwrite=False, stop_revision=None,
1476
_hook_master=None, run_hooks=True):
1479
:param _hook_master: Private parameter - set the branch to
1480
be supplied as the master to push hooks.
1481
:param run_hooks: Private parameter - if false, this branch
1482
is being called because it's the master of the primary branch,
1483
so it should not run its hooks.
1485
result = PullResult()
1486
result.source_branch = source
1487
result.target_branch = self
1016
def pull(self, source, overwrite=False):
1017
"""See Branch.pull."""
1488
1018
source.lock_read()
1490
result.old_revno, result.old_revid = self.last_revision_info()
1020
old_count = len(self.revision_history())
1492
self.update_revisions(source, stop_revision)
1022
self.update_revisions(source)
1493
1023
except DivergedBranches:
1494
1024
if not overwrite:
1497
if stop_revision is None:
1498
stop_revision = source.last_revision()
1499
self.generate_revision_history(stop_revision)
1500
result.tag_conflicts = source.tags.merge_to(self.tags)
1501
result.new_revno, result.new_revid = self.last_revision_info()
1503
result.master_branch = _hook_master
1504
result.local_branch = self
1506
result.master_branch = self
1507
result.local_branch = None
1509
for hook in Branch.hooks['post_pull']:
1026
self.set_revision_history(source.revision_history())
1027
new_count = len(self.revision_history())
1028
return new_count - old_count
1512
1030
source.unlock()
1515
def _get_parent_location(self):
1032
def get_parent(self):
1033
"""See Branch.get_parent."""
1516
1035
_locs = ['parent', 'pull', 'x-pull']
1517
1036
for l in _locs:
1519
return self.control_files.get(l).read().strip('\n')
1038
return self.controlfile(l, 'r').read().strip('\n')
1040
if e.errno != errno.ENOENT:
1525
def push(self, target, overwrite=False, stop_revision=None,
1526
_override_hook_source_branch=None):
1529
This is the basic concrete implementation of push()
1531
:param _override_hook_source_branch: If specified, run
1532
the hooks passing this Branch as the source, rather than self.
1533
This is for use of RemoteBranch, where push is delegated to the
1534
underlying vfs-based Branch.
1536
# TODO: Public option to disable running hooks - should be trivial but
1540
result = self._push_with_bound_branches(target, overwrite,
1542
_override_hook_source_branch=_override_hook_source_branch)
1547
def _push_with_bound_branches(self, target, overwrite,
1549
_override_hook_source_branch=None):
1550
"""Push from self into target, and into target's master if any.
1552
This is on the base BzrBranch class even though it doesn't support
1553
bound branches because the *target* might be bound.
1556
if _override_hook_source_branch:
1557
result.source_branch = _override_hook_source_branch
1558
for hook in Branch.hooks['post_push']:
1561
bound_location = target.get_bound_location()
1562
if bound_location and target.base != bound_location:
1563
# there is a master branch.
1565
# XXX: Why the second check? Is it even supported for a branch to
1566
# be bound to itself? -- mbp 20070507
1567
master_branch = target.get_master_branch()
1568
master_branch.lock_write()
1570
# push into the master from this branch.
1571
self._basic_push(master_branch, overwrite, stop_revision)
1572
# and push into the target branch from this. Note that we push from
1573
# this branch again, because its considered the highest bandwidth
1575
result = self._basic_push(target, overwrite, stop_revision)
1576
result.master_branch = master_branch
1577
result.local_branch = target
1581
master_branch.unlock()
1584
result = self._basic_push(target, overwrite, stop_revision)
1585
# TODO: Why set master_branch and local_branch if there's no
1586
# binding? Maybe cleaner to just leave them unset? -- mbp
1588
result.master_branch = target
1589
result.local_branch = None
1593
def _basic_push(self, target, overwrite, stop_revision):
1594
"""Basic implementation of push without bound branches or hooks.
1596
Must be called with self read locked and target write locked.
1598
result = PushResult()
1599
result.source_branch = self
1600
result.target_branch = target
1601
result.old_revno, result.old_revid = target.last_revision_info()
1603
target.update_revisions(self, stop_revision)
1604
except DivergedBranches:
1608
target.set_revision_history(self.revision_history())
1609
result.tag_conflicts = self.tags.merge_to(target.tags)
1610
result.new_revno, result.new_revid = target.last_revision_info()
1613
def get_parent(self):
1614
"""See Branch.get_parent."""
1616
assert self.base[-1] == '/'
1617
parent = self._get_parent_location()
1620
# This is an old-format absolute path to a local branch
1621
# turn it into a url
1622
if parent.startswith('/'):
1623
parent = urlutils.local_path_to_url(parent.decode('utf8'))
1625
return urlutils.join(self.base[:-1], parent)
1626
except errors.InvalidURLJoin, e:
1627
raise errors.InaccessibleParent(parent, self.base)
1044
def get_push_location(self):
1045
"""See Branch.get_push_location."""
1046
config = bzrlib.config.BranchConfig(self)
1047
push_loc = config.get_user_option('push_location')
1629
1050
def set_push_location(self, location):
1630
1051
"""See Branch.set_push_location."""
1631
self.get_config().set_user_option(
1632
'push_location', location,
1633
store=_mod_config.STORE_LOCATION_NORECURSE)
1052
config = bzrlib.config.LocationConfig(self.base)
1053
config.set_user_option('push_location', location)
1635
1055
@needs_write_lock
1636
1056
def set_parent(self, url):
1637
1057
"""See Branch.set_parent."""
1638
1058
# TODO: Maybe delete old location files?
1639
# URLs should never be unicode, even on the local fs,
1640
# FIXUP this and get_parent in a future branch format bump:
1641
# read and rewrite the file, and have the new format code read
1642
# using .get not .get_utf8. RBC 20060125
1644
if isinstance(url, unicode):
1646
url = url.encode('ascii')
1647
except UnicodeEncodeError:
1648
raise errors.InvalidURL(url,
1649
"Urls must be 7-bit ascii, "
1650
"use bzrlib.urlutils.escape")
1651
url = urlutils.relative_url(self.base, url)
1652
self._set_parent_location(url)
1654
def _set_parent_location(self, url):
1656
self.control_files._transport.delete('parent')
1658
assert isinstance(url, str)
1659
self.control_files.put_bytes('parent', url + '\n')
1661
@deprecated_function(zero_nine)
1059
from bzrlib.atomicfile import AtomicFile
1060
f = AtomicFile(self.controlfilename('parent'))
1662
1067
def tree_config(self):
1663
"""DEPRECATED; call get_config instead.
1664
TreeConfig has become part of BranchConfig."""
1665
1068
return TreeConfig(self)
1668
class BzrBranch5(BzrBranch):
1669
"""A format 5 branch. This supports new features over plan branches.
1671
It has support for a master_branch which is the data for bound branches.
1070
def sign_revision(self, revision_id, gpg_strategy):
1071
"""See Branch.sign_revision."""
1072
plaintext = Testament.from_revision(self, revision_id).as_short_text()
1073
self.store_revision_signature(gpg_strategy, plaintext, revision_id)
1076
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1077
"""See Branch.store_revision_signature."""
1078
self.revision_store.add(StringIO(gpg_strategy.sign(plaintext)),
1082
class ScratchBranch(BzrBranch):
1083
"""Special test class: a branch that cleans up after itself.
1085
>>> b = ScratchBranch()
1089
>>> b._transport.__del__()
1679
super(BzrBranch5, self).__init__(_format=_format,
1680
_control_files=_control_files,
1682
_repository=_repository)
1685
def pull(self, source, overwrite=False, stop_revision=None,
1687
"""Pull from source into self, updating my master if any.
1689
:param run_hooks: Private parameter - if false, this branch
1690
is being called because it's the master of the primary branch,
1691
so it should not run its hooks.
1693
bound_location = self.get_bound_location()
1694
master_branch = None
1695
if bound_location and source.base != bound_location:
1696
# not pulling from master, so we need to update master.
1697
master_branch = self.get_master_branch()
1698
master_branch.lock_write()
1701
# pull from source into master.
1702
master_branch.pull(source, overwrite, stop_revision,
1704
return super(BzrBranch5, self).pull(source, overwrite,
1705
stop_revision, _hook_master=master_branch,
1706
run_hooks=run_hooks)
1709
master_branch.unlock()
1711
def get_bound_location(self):
1713
return self.control_files.get_utf8('bound').read()[:-1]
1714
except errors.NoSuchFile:
1718
def get_master_branch(self):
1719
"""Return the branch we are bound to.
1721
:return: Either a Branch, or None
1723
This could memoise the branch, but if thats done
1724
it must be revalidated on each new lock.
1725
So for now we just don't memoise it.
1726
# RBC 20060304 review this decision.
1728
bound_loc = self.get_bound_location()
1732
return Branch.open(bound_loc)
1733
except (errors.NotBranchError, errors.ConnectionError), e:
1734
raise errors.BoundBranchConnectionFailure(
1738
def set_bound_location(self, location):
1739
"""Set the target where this branch is bound to.
1741
:param location: URL to the target branch
1744
self.control_files.put_utf8('bound', location+'\n')
1094
def __init__(self, files=[], dirs=[], transport=None):
1095
"""Make a test branch.
1097
This creates a temporary directory and runs init-tree in it.
1099
If any files are listed, they are created in the working copy.
1101
if transport is None:
1102
transport = bzrlib.transport.local.ScratchTransport()
1103
super(ScratchBranch, self).__init__(transport, init=True)
1747
self.control_files._transport.delete('bound')
1105
super(ScratchBranch, self).__init__(transport)
1108
self._transport.mkdir(d)
1111
self._transport.put(f, 'content of %s' % f)
1116
>>> orig = ScratchBranch(files=["file1", "file2"])
1117
>>> clone = orig.clone()
1118
>>> if os.name != 'nt':
1119
... os.path.samefile(orig.base, clone.base)
1121
... orig.base == clone.base
1124
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1127
from shutil import copytree
1128
from tempfile import mkdtemp
1131
copytree(self.base, base, symlinks=True)
1132
return ScratchBranch(
1133
transport=bzrlib.transport.local.ScratchTransport(base))
1136
######################################################################
1140
def is_control_file(filename):
1141
## FIXME: better check
1142
filename = os.path.normpath(filename)
1143
while filename != '':
1144
head, tail = os.path.split(filename)
1145
## mutter('check %r for control file' % ((head, tail), ))
1146
if tail == bzrlib.BZRDIR:
1753
def bind(self, other):
1754
"""Bind this branch to the branch other.
1756
This does not push or pull data between the branches, though it does
1757
check for divergence to raise an error when the branches are not
1758
either the same, or one a prefix of the other. That behaviour may not
1759
be useful, so that check may be removed in future.
1761
:param other: The branch to bind to
1764
# TODO: jam 20051230 Consider checking if the target is bound
1765
# It is debatable whether you should be able to bind to
1766
# a branch which is itself bound.
1767
# Committing is obviously forbidden,
1768
# but binding itself may not be.
1769
# Since we *have* to check at commit time, we don't
1770
# *need* to check here
1772
# we want to raise diverged if:
1773
# last_rev is not in the other_last_rev history, AND
1774
# other_last_rev is not in our history, and do it without pulling
1776
last_rev = self.last_revision()
1777
if last_rev is not None:
1780
other_last_rev = other.last_revision()
1781
if other_last_rev is not None:
1782
# neither branch is new, we have to do some work to
1783
# ascertain diversion.
1784
remote_graph = other.repository.get_revision_graph(
1786
local_graph = self.repository.get_revision_graph(last_rev)
1787
if (last_rev not in remote_graph and
1788
other_last_rev not in local_graph):
1789
raise errors.DivergedBranches(self, other)
1792
self.set_bound_location(other.base)
1796
"""If bound, unbind"""
1797
return self.set_bound_location(None)
1801
"""Synchronise this branch with the master branch if any.
1803
:return: None or the last_revision that was pivoted out during the
1806
master = self.get_master_branch()
1807
if master is not None:
1808
old_tip = self.last_revision()
1809
self.pull(master, overwrite=True)
1810
if old_tip in self.repository.get_ancestry(self.last_revision()):
1816
class BzrBranchExperimental(BzrBranch5):
1817
"""Bzr experimental branch format
1820
- a revision-history file.
1822
- a lock dir guarding the branch itself
1823
- all of this stored in a branch/ subdirectory
1824
- works with shared repositories.
1825
- a tag dictionary in the branch
1827
This format is new in bzr 0.15, but shouldn't be used for real data,
1830
This class acts as it's own BranchFormat.
1833
_matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1836
def get_format_string(cls):
1837
"""See BranchFormat.get_format_string()."""
1838
return "Bazaar-NG branch format experimental\n"
1841
def get_format_description(cls):
1842
"""See BranchFormat.get_format_description()."""
1843
return "Experimental branch format"
1846
def get_reference(cls, a_bzrdir):
1847
"""Get the target reference of the branch in a_bzrdir.
1849
format probing must have been completed before calling
1850
this method - it is assumed that the format of the branch
1851
in a_bzrdir is correct.
1853
:param a_bzrdir: The bzrdir to get the branch data from.
1854
:return: None if the branch is not a reference branch.
1859
def _initialize_control_files(cls, a_bzrdir, utf8_files, lock_filename,
1861
branch_transport = a_bzrdir.get_branch_transport(cls)
1862
control_files = lockable_files.LockableFiles(branch_transport,
1863
lock_filename, lock_class)
1864
control_files.create_lock()
1865
control_files.lock_write()
1867
for filename, content in utf8_files:
1868
control_files.put_utf8(filename, content)
1870
control_files.unlock()
1873
def initialize(cls, a_bzrdir):
1874
"""Create a branch of this format in a_bzrdir."""
1875
utf8_files = [('format', cls.get_format_string()),
1876
('revision-history', ''),
1877
('branch-name', ''),
1880
cls._initialize_control_files(a_bzrdir, utf8_files,
1881
'lock', lockdir.LockDir)
1882
return cls.open(a_bzrdir, _found=True)
1885
def open(cls, a_bzrdir, _found=False):
1886
"""Return the branch object for a_bzrdir
1888
_found is a private parameter, do not use it. It is used to indicate
1889
if format probing has already be done.
1892
format = BranchFormat.find_format(a_bzrdir)
1893
assert format.__class__ == cls
1894
transport = a_bzrdir.get_branch_transport(None)
1895
control_files = lockable_files.LockableFiles(transport, 'lock',
1897
return cls(_format=cls,
1898
_control_files=control_files,
1900
_repository=a_bzrdir.find_repository())
1903
def is_supported(cls):
1906
def _make_tags(self):
1907
return BasicTags(self)
1910
def supports_tags(cls):
1914
BranchFormat.register_format(BzrBranchExperimental)
1917
class BzrBranch6(BzrBranch5):
1920
def last_revision_info(self):
1921
revision_string = self.control_files.get('last-revision').read()
1922
revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
1923
revision_id = cache_utf8.get_cached_utf8(revision_id)
1925
return revno, revision_id
1927
def last_revision(self):
1928
"""Return last revision id, or None"""
1929
revision_id = self.last_revision_info()[1]
1930
if revision_id == _mod_revision.NULL_REVISION:
1934
def _write_last_revision_info(self, revno, revision_id):
1935
"""Simply write out the revision id, with no checks.
1937
Use set_last_revision_info to perform this safely.
1939
Does not update the revision_history cache.
1940
Intended to be called by set_last_revision_info and
1941
_write_revision_history.
1943
if revision_id is None:
1944
revision_id = 'null:'
1945
out_string = '%d %s\n' % (revno, revision_id)
1946
self.control_files.put_bytes('last-revision', out_string)
1949
def set_last_revision_info(self, revno, revision_id):
1950
revision_id = osutils.safe_revision_id(revision_id)
1951
if self._get_append_revisions_only():
1952
self._check_history_violation(revision_id)
1953
self._write_last_revision_info(revno, revision_id)
1954
self._clear_cached_state()
1956
def _check_history_violation(self, revision_id):
1957
last_revision = self.last_revision()
1958
if last_revision is None:
1960
if last_revision not in self._lefthand_history(revision_id):
1961
raise errors.AppendRevisionsOnlyViolation(self.base)
1963
def _gen_revision_history(self):
1964
"""Generate the revision history from last revision
1966
history = list(self.repository.iter_reverse_revision_history(
1967
self.last_revision()))
1971
def _write_revision_history(self, history):
1972
"""Factored out of set_revision_history.
1974
This performs the actual writing to disk, with format-specific checks.
1975
It is intended to be called by BzrBranch5.set_revision_history.
1977
if len(history) == 0:
1978
last_revision = 'null:'
1980
if history != self._lefthand_history(history[-1]):
1981
raise errors.NotLefthandHistory(history)
1982
last_revision = history[-1]
1983
if self._get_append_revisions_only():
1984
self._check_history_violation(last_revision)
1985
self._write_last_revision_info(len(history), last_revision)
1988
def append_revision(self, *revision_ids):
1989
revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
1990
if len(revision_ids) == 0:
1992
prev_revno, prev_revision = self.last_revision_info()
1993
for revision in self.repository.get_revisions(revision_ids):
1994
if prev_revision == _mod_revision.NULL_REVISION:
1995
if revision.parent_ids != []:
1996
raise errors.NotLeftParentDescendant(self, prev_revision,
1997
revision.revision_id)
1999
if revision.parent_ids[0] != prev_revision:
2000
raise errors.NotLeftParentDescendant(self, prev_revision,
2001
revision.revision_id)
2002
prev_revision = revision.revision_id
2003
self.set_last_revision_info(prev_revno + len(revision_ids),
2007
def _set_parent_location(self, url):
2008
"""Set the parent branch"""
2009
self._set_config_location('parent_location', url, make_relative=True)
2012
def _get_parent_location(self):
2013
"""Set the parent branch"""
2014
return self._get_config_location('parent_location')
2016
def set_push_location(self, location):
2017
"""See Branch.set_push_location."""
2018
self._set_config_location('push_location', location)
2020
def set_bound_location(self, location):
2021
"""See Branch.set_push_location."""
2023
config = self.get_config()
2024
if location is None:
2025
if config.get_user_option('bound') != 'True':
2028
config.set_user_option('bound', 'False')
2031
self._set_config_location('bound_location', location,
2033
config.set_user_option('bound', 'True')
2036
def _get_bound_location(self, bound):
2037
"""Return the bound location in the config file.
2039
Return None if the bound parameter does not match"""
2040
config = self.get_config()
2041
config_bound = (config.get_user_option('bound') == 'True')
2042
if config_bound != bound:
2044
return self._get_config_location('bound_location', config=config)
2046
def get_bound_location(self):
2047
"""See Branch.set_push_location."""
2048
return self._get_bound_location(True)
2050
def get_old_bound_location(self):
2051
"""See Branch.get_old_bound_location"""
2052
return self._get_bound_location(False)
2054
def set_append_revisions_only(self, enabled):
2059
self.get_config().set_user_option('append_revisions_only', value)
2061
def _get_append_revisions_only(self):
2062
value = self.get_config().get_user_option('append_revisions_only')
2063
return value == 'True'
2065
def _synchronize_history(self, destination, revision_id):
2066
"""Synchronize last revision and revision history between branches.
2068
This version is most efficient when the destination is also a
2069
BzrBranch6, but works for BzrBranch5, as long as the destination's
2070
repository contains all the lefthand ancestors of the intended
2071
last_revision. If not, set_last_revision_info will fail.
2073
:param destination: The branch to copy the history into
2074
:param revision_id: The revision-id to truncate history at. May
2075
be None to copy complete history.
2077
if revision_id is None:
2078
revno, revision_id = self.last_revision_info()
2080
revno = self.revision_id_to_revno(revision_id)
2081
destination.set_last_revision_info(revno, revision_id)
2083
def _make_tags(self):
2084
return BasicTags(self)
2087
class BranchTestProviderAdapter(object):
2088
"""A tool to generate a suite testing multiple branch formats at once.
2090
This is done by copying the test once for each transport and injecting
2091
the transport_server, transport_readonly_server, and branch_format
2092
classes into each copy. Each copy is also given a new id() to make it
2096
def __init__(self, transport_server, transport_readonly_server, formats,
2097
vfs_transport_factory=None):
2098
self._transport_server = transport_server
2099
self._transport_readonly_server = transport_readonly_server
2100
self._formats = formats
2102
def adapt(self, test):
2103
result = TestSuite()
2104
for branch_format, bzrdir_format in self._formats:
2105
new_test = deepcopy(test)
2106
new_test.transport_server = self._transport_server
2107
new_test.transport_readonly_server = self._transport_readonly_server
2108
new_test.bzrdir_format = bzrdir_format
2109
new_test.branch_format = branch_format
2110
def make_new_test_id():
2111
# the format can be either a class or an instance
2112
name = getattr(branch_format, '__name__',
2113
branch_format.__class__.__name__)
2114
new_id = "%s(%s)" % (new_test.id(), name)
2115
return lambda: new_id
2116
new_test.id = make_new_test_id()
2117
result.addTest(new_test)
2121
######################################################################
2122
# results of operations
2125
class _Result(object):
2127
def _show_tag_conficts(self, to_file):
2128
if not getattr(self, 'tag_conflicts', None):
2130
to_file.write('Conflicting tags:\n')
2131
for name, value1, value2 in self.tag_conflicts:
2132
to_file.write(' %s\n' % (name, ))
2135
class PullResult(_Result):
2136
"""Result of a Branch.pull operation.
2138
:ivar old_revno: Revision number before pull.
2139
:ivar new_revno: Revision number after pull.
2140
:ivar old_revid: Tip revision id before pull.
2141
:ivar new_revid: Tip revision id after pull.
2142
:ivar source_branch: Source (local) branch object.
2143
:ivar master_branch: Master branch of the target, or None.
2144
:ivar target_branch: Target/destination branch object.
2148
# DEPRECATED: pull used to return the change in revno
2149
return self.new_revno - self.old_revno
2151
def report(self, to_file):
2152
if self.old_revid == self.new_revid:
2153
to_file.write('No revisions to pull.\n')
2155
to_file.write('Now on revision %d.\n' % self.new_revno)
2156
self._show_tag_conficts(to_file)
2159
class PushResult(_Result):
2160
"""Result of a Branch.push operation.
2162
:ivar old_revno: Revision number before push.
2163
:ivar new_revno: Revision number after push.
2164
:ivar old_revid: Tip revision id before push.
2165
:ivar new_revid: Tip revision id after push.
2166
:ivar source_branch: Source branch object.
2167
:ivar master_branch: Master branch of the target, or None.
2168
:ivar target_branch: Target/destination branch object.
2172
# DEPRECATED: push used to return the change in revno
2173
return self.new_revno - self.old_revno
2175
def report(self, to_file):
2176
"""Write a human-readable description of the result."""
2177
if self.old_revid == self.new_revid:
2178
to_file.write('No new revisions to push.\n')
2180
to_file.write('Pushed up to revision %d.\n' % self.new_revno)
2181
self._show_tag_conficts(to_file)
2184
class BranchCheckResult(object):
2185
"""Results of checking branch consistency.
2190
def __init__(self, branch):
2191
self.branch = branch
2193
def report_results(self, verbose):
2194
"""Report the check results via trace.note.
2196
:param verbose: Requests more detailed display of what was checked,
2199
note('checked branch %s format %s',
2201
self.branch._format)
2204
class Converter5to6(object):
2205
"""Perform an in-place upgrade of format 5 to format 6"""
2207
def convert(self, branch):
2208
# Data for 5 and 6 can peacefully coexist.
2209
format = BzrBranchFormat6()
2210
new_branch = format.open(branch.bzrdir, _found=True)
2212
# Copy source data into target
2213
new_branch.set_last_revision_info(*branch.last_revision_info())
2214
new_branch.set_parent(branch.get_parent())
2215
new_branch.set_bound_location(branch.get_bound_location())
2216
new_branch.set_push_location(branch.get_push_location())
2218
# New branch has no tags by default
2219
new_branch.tags._set_tag_dict({})
2221
# Copying done; now update target format
2222
new_branch.control_files.put_utf8('format',
2223
format.get_format_string())
2225
# Clean up old files
2226
new_branch.control_files._transport.delete('revision-history')
2228
branch.set_parent(None)
2231
branch.set_bound_location(None)
1148
if filename == head:
added
removed
bzrlib/branch.py
