« back to all changes in this revision
Viewing changes to bzrlib/bzrdir.py
- browse files at revision 5363.2.2
- compare with another revision
- compare with revision 974.1.1
- download diff
- download tarball
- view history from revision 5363.2.2
- Committer: Jelmer Vernooij
- Date: 2010-08-02 11:20:39 UTC
- mto: This revision was merged to the branch mainline in revision 5389.
- Revision ID: jelmer@samba.org-20100802112039-j96qqgswdytb4are
Rename per_bzrdir => per_controldir.
- files renamed:
- bzrlib/tests/per_bzrdir/ => bzrlib/tests/per_controldir/
- bzrlib/tests/per_bzrdir/test_bzrdir.py => bzrlib/tests/per_controldir/test_controldir.py
- bzrlib/tests/per_bzrdir_colo/ => bzrlib/tests/per_controldir_colo/
- files modified:
- bzrlib/bzrdir.py
added
removed
bzrlib/bzrdir.py
75
75
from bzrlib.weave import Weave
76
76
""")
77
77
78
from bzrlib.controldir import (
79
ControlDir,
80
)
81
78
82
from bzrlib.trace import (
79
83
mutter,
80
84
note,
86
90
registry,
87
91
symbol_versioning,
88
92
)
89
90
93
94
91
95
class ControlComponent(object):
92
96
"""Abstract base class for control directory components.
93
94
This provides interfaces that are common across bzrdirs,
97
98
This provides interfaces that are common across bzrdirs,
95
99
repositories, branches, and workingtree control directories.
96
97
They all expose two urls and transports: the *user* URL is the
98
one that stops above the control directory (eg .bzr) and that
100
101
They all expose two urls and transports: the *user* URL is the
102
one that stops above the control directory (eg .bzr) and that
99
103
should normally be used in messages, and the *control* URL is
100
104
under that in eg .bzr/checkout and is used to read the control
101
105
files.
102
103
This can be used as a mixin and is intended to fit with
106
107
This can be used as a mixin and is intended to fit with
104
108
foreign formats.
105
109
"""
106
110
107
111
@property
108
112
def control_transport(self):
109
113
raise NotImplementedError
110
114
111
115
@property
112
116
def control_url(self):
113
117
return self.control_transport.base
114
118
115
119
@property
116
120
def user_transport(self):
117
121
raise NotImplementedError
118
122
119
123
@property
120
124
def user_url(self):
121
125
return self.user_transport.base
122
123
124
class BzrDir(ControlComponent):
126
127
128
class BzrDir(ControlComponent,ControlDir):
125
129
"""A .bzr control diretory.
126
130
127
131
BzrDir instances let you create or open any of the things that can be
158
162
return
159
163
thing_to_unlock.break_lock()
160
164
161
def can_convert_format(self):
162
"""Return true if this bzrdir is one whose format we can convert from."""
163
return True
164
165
165
def check_conversion_target(self, target_format):
166
166
"""Check that a bzrdir as a whole can be converted to a new format."""
167
167
# The only current restriction is that the repository content can be
241
241
"""
242
242
# Overview: put together a broad description of what we want to end up
243
243
# with; then make as few api calls as possible to do it.
244
244
245
245
# We may want to create a repo/branch/tree, if we do so what format
246
246
# would we want for each:
247
247
require_stacking = (stacked_on is not None)
248
248
format = self.cloning_metadir(require_stacking)
249
249
250
250
# Figure out what objects we want:
251
251
try:
252
252
local_repo = self.find_repository()
388
388
for subdir in sorted(subdirs, reverse=True):
389
389
pending.append(current_transport.clone(subdir))
390
390
391
def list_branches(self):
392
"""Return a sequence of all branches local to this control directory.
393
394
"""
395
try:
396
return [self.open_branch()]
397
except (errors.NotBranchError, errors.NoRepositoryPresent):
398
return []
399
400
391
@staticmethod
401
392
def find_branches(transport):
402
393
"""Find all branches under a transport.
425
416
ret.extend(branches)
426
417
return ret
427
418
428
def destroy_repository(self):
429
"""Destroy the repository in this BzrDir"""
430
raise NotImplementedError(self.destroy_repository)
431
432
def create_branch(self, name=None):
433
"""Create a branch in this BzrDir.
434
435
:param name: Name of the colocated branch to create, None for
436
the default branch.
437
438
The bzrdir's format will control what branch format is created.
439
For more control see BranchFormatXX.create(a_bzrdir).
440
"""
441
raise NotImplementedError(self.create_branch)
442
443
def destroy_branch(self, name=None):
444
"""Destroy a branch in this BzrDir.
445
446
:param name: Name of the branch to destroy, None for the default
447
branch.
448
"""
449
raise NotImplementedError(self.destroy_branch)
450
451
419
@staticmethod
452
420
def create_branch_and_repo(base, force_new_repo=False, format=None):
453
421
"""Create a new BzrDir, Branch and Repository at the url 'base'.
602
570
format=format).bzrdir
603
571
return bzrdir.create_workingtree()
604
572
605
def create_workingtree(self, revision_id=None, from_branch=None,
606
accelerator_tree=None, hardlink=False):
607
"""Create a working tree at this BzrDir.
608
609
:param revision_id: create it as of this revision id.
610
:param from_branch: override bzrdir branch (for lightweight checkouts)
611
:param accelerator_tree: A tree which can be used for retrieving file
612
contents more quickly than the revision tree, i.e. a workingtree.
613
The revision tree will be used for cases where accelerator_tree's
614
content is different.
615
"""
616
raise NotImplementedError(self.create_workingtree)
617
618
573
def backup_bzrdir(self):
619
574
"""Backup this bzr control directory.
620
575
668
623
else:
669
624
pass
670
625
671
def destroy_workingtree(self):
672
"""Destroy the working tree at this BzrDir.
673
674
Formats that do not support this may raise UnsupportedOperation.
675
"""
676
raise NotImplementedError(self.destroy_workingtree)
677
678
def destroy_workingtree_metadata(self):
679
"""Destroy the control files for the working tree at this BzrDir.
680
681
The contents of working tree files are not affected.
682
Formats that do not support this may raise UnsupportedOperation.
683
"""
684
raise NotImplementedError(self.destroy_workingtree_metadata)
685
686
626
def _find_containing(self, evaluate):
687
627
"""Find something in a containing control directory.
688
628
737
677
raise errors.NoRepositoryPresent(self)
738
678
return found_repo
739
679
740
def get_branch_reference(self, name=None):
741
"""Return the referenced URL for the branch in this bzrdir.
742
743
:param name: Optional colocated branch name
744
:raises NotBranchError: If there is no Branch.
745
:raises NoColocatedBranchSupport: If a branch name was specified
746
but colocated branches are not supported.
747
:return: The URL the branch in this bzrdir references if it is a
748
reference branch, or None for regular branches.
749
"""
750
if name is not None:
751
raise errors.NoColocatedBranchSupport(self)
752
return None
753
754
def get_branch_transport(self, branch_format, name=None):
755
"""Get the transport for use by branch format in this BzrDir.
756
757
Note that bzr dirs that do not support format strings will raise
758
IncompatibleFormat if the branch format they are given has
759
a format string, and vice versa.
760
761
If branch_format is None, the transport is returned with no
762
checking. If it is not None, then the returned transport is
763
guaranteed to point to an existing directory ready for use.
764
"""
765
raise NotImplementedError(self.get_branch_transport)
766
767
680
def _find_creation_modes(self):
768
681
"""Determine the appropriate modes for files and directories.
769
682
808
721
self._find_creation_modes()
809
722
return self._dir_mode
810
723
811
def get_repository_transport(self, repository_format):
812
"""Get the transport for use by repository format in this BzrDir.
813
814
Note that bzr dirs that do not support format strings will raise
815
IncompatibleFormat if the repository format they are given has
816
a format string, and vice versa.
817
818
If repository_format is None, the transport is returned with no
819
checking. If it is not None, then the returned transport is
820
guaranteed to point to an existing directory ready for use.
821
"""
822
raise NotImplementedError(self.get_repository_transport)
823
824
def get_workingtree_transport(self, tree_format):
825
"""Get the transport for use by workingtree format in this BzrDir.
826
827
Note that bzr dirs that do not support format strings will raise
828
IncompatibleFormat if the workingtree format they are given has a
829
format string, and vice versa.
830
831
If workingtree_format is None, the transport is returned with no
832
checking. If it is not None, then the returned transport is
833
guaranteed to point to an existing directory ready for use.
834
"""
835
raise NotImplementedError(self.get_workingtree_transport)
836
837
724
def get_config(self):
838
725
"""Get configuration for this BzrDir."""
839
726
return config.BzrDirConfig(self)
857
744
self.transport = _transport.clone('.bzr')
858
745
self.root_transport = _transport
859
746
self._mode_check_done = False
860
747
861
748
@property
862
749
def user_transport(self):
863
750
return self.root_transport
864
751
865
752
@property
866
753
def control_transport(self):
867
754
return self.transport
873
760
874
761
This is true IF and ONLY IF the filename is part of the namespace reserved
875
762
for bzr control dirs. Currently this is the '.bzr' directory in the root
876
of the root_transport. it is expected that plugins will need to extend
877
this in the future - for instance to make bzr talk with svn working
878
trees.
763
of the root_transport.
879
764
"""
880
765
# this might be better on the BzrDirFormat class because it refers to
881
766
# all the possible bzrdir disk formats.
885
770
# add new tests for it to the appropriate place.
886
771
return filename == '.bzr' or filename.startswith('.bzr/')
887
772
888
def needs_format_conversion(self, format=None):
889
"""Return true if this bzrdir needs convert_format run on it.
890
891
For instance, if the repository format is out of date but the
892
branch and working tree are not, this should return True.
893
894
:param format: Optional parameter indicating a specific desired
895
format we plan to arrive at.
896
"""
897
raise NotImplementedError(self.needs_format_conversion)
898
899
773
@staticmethod
900
774
def open_unsupported(base):
901
775
"""Open a branch which is not supported."""
945
819
BzrDir._check_supported(format, _unsupported)
946
820
return format.open(transport, _found=True)
947
821
948
def open_branch(self, name=None, unsupported=False,
949
ignore_fallbacks=False):
950
"""Open the branch object at this BzrDir if one is present.
951
952
If unsupported is True, then no longer supported branch formats can
953
still be opened.
954
955
TODO: static convenience version of this?
956
"""
957
raise NotImplementedError(self.open_branch)
958
959
822
@staticmethod
960
823
def open_containing(url, possible_transports=None):
961
824
"""Open an existing branch which contains url.
1071
934
raise errors.NotBranchError(location)
1072
935
return tree, branch, branch.repository, relpath
1073
936
1074
def open_repository(self, _unsupported=False):
1075
"""Open the repository object at this BzrDir if one is present.
1076
1077
This will not follow the Branch object pointer - it's strictly a direct
1078
open facility. Most client code should use open_branch().repository to
1079
get at a repository.
1080
1081
:param _unsupported: a private parameter, not part of the api.
1082
TODO: static convenience version of this?
1083
"""
1084
raise NotImplementedError(self.open_repository)
1085
1086
def open_workingtree(self, _unsupported=False,
1087
recommend_upgrade=True, from_branch=None):
1088
"""Open the workingtree object at this BzrDir if one is present.
1089
1090
:param recommend_upgrade: Optional keyword parameter, when True (the
1091
default), emit through the ui module a recommendation that the user
1092
upgrade the working tree when the workingtree being opened is old
1093
(but still fully supported).
1094
:param from_branch: override bzrdir branch (for lightweight checkouts)
1095
"""
1096
raise NotImplementedError(self.open_workingtree)
1097
1098
def has_branch(self, name=None):
1099
"""Tell if this bzrdir contains a branch.
1100
1101
Note: if you're going to open the branch, you should just go ahead
1102
and try, and not ask permission first. (This method just opens the
1103
branch and discards it, and that's somewhat expensive.)
1104
"""
1105
try:
1106
self.open_branch(name)
1107
return True
1108
except errors.NotBranchError:
1109
return False
1110
1111
def has_workingtree(self):
1112
"""Tell if this bzrdir contains a working tree.
1113
1114
This will still raise an exception if the bzrdir has a workingtree that
1115
is remote & inaccessible.
1116
1117
Note: if you're going to open the working tree, you should just go ahead
1118
and try, and not ask permission first. (This method just opens the
1119
workingtree and discards it, and that's somewhat expensive.)
1120
"""
1121
try:
1122
self.open_workingtree(recommend_upgrade=False)
1123
return True
1124
except errors.NoWorkingTree:
1125
return False
1126
1127
937
def _cloning_metadir(self):
1128
938
"""Produce a metadir suitable for cloning with.
1129
939
1187
997
format.require_stacking()
1188
998
return format
1189
999
1190
def checkout_metadir(self):
1191
return self.cloning_metadir()
1192
1193
def sprout(self, url, revision_id=None, force_new_repo=False,
1194
recurse='down', possible_transports=None,
1195
accelerator_tree=None, hardlink=False, stacked=False,
1196
source_branch=None, create_tree_if_local=True):
1197
"""Create a copy of this bzrdir prepared for use as a new line of
1198
development.
1199
1200
If url's last component does not exist, it will be created.
1201
1202
Attributes related to the identity of the source branch like
1203
branch nickname will be cleaned, a working tree is created
1204
whether one existed before or not; and a local branch is always
1205
created.
1206
1207
if revision_id is not None, then the clone operation may tune
1208
itself to download less data.
1209
:param accelerator_tree: A tree which can be used for retrieving file
1210
contents more quickly than the revision tree, i.e. a workingtree.
1211
The revision tree will be used for cases where accelerator_tree's
1212
content is different.
1213
:param hardlink: If true, hard-link files from accelerator_tree,
1214
where possible.
1215
:param stacked: If true, create a stacked branch referring to the
1216
location of this control directory.
1217
:param create_tree_if_local: If true, a working-tree will be created
1218
when working locally.
1219
"""
1220
target_transport = get_transport(url, possible_transports)
1221
target_transport.ensure_base()
1222
cloning_format = self.cloning_metadir(stacked)
1223
# Create/update the result branch
1224
result = cloning_format.initialize_on_transport(target_transport)
1225
# if a stacked branch wasn't requested, we don't create one
1226
# even if the origin was stacked
1227
stacked_branch_url = None
1228
if source_branch is not None:
1229
if stacked:
1230
stacked_branch_url = self.root_transport.base
1231
source_repository = source_branch.repository
1232
else:
1233
try:
1234
source_branch = self.open_branch()
1235
source_repository = source_branch.repository
1236
if stacked:
1237
stacked_branch_url = self.root_transport.base
1238
except errors.NotBranchError:
1239
source_branch = None
1240
try:
1241
source_repository = self.open_repository()
1242
except errors.NoRepositoryPresent:
1243
source_repository = None
1244
repository_policy = result.determine_repository_policy(
1245
force_new_repo, stacked_branch_url, require_stacking=stacked)
1246
result_repo, is_new_repo = repository_policy.acquire_repository()
1247
is_stacked = stacked or (len(result_repo._fallback_repositories) != 0)
1248
if is_new_repo and revision_id is not None and not is_stacked:
1249
fetch_spec = graph.PendingAncestryResult(
1250
[revision_id], source_repository)
1251
else:
1252
fetch_spec = None
1253
if source_repository is not None:
1254
# Fetch while stacked to prevent unstacked fetch from
1255
# Branch.sprout.
1256
if fetch_spec is None:
1257
result_repo.fetch(source_repository, revision_id=revision_id)
1258
else:
1259
result_repo.fetch(source_repository, fetch_spec=fetch_spec)
1260
1261
if source_branch is None:
1262
# this is for sprouting a bzrdir without a branch; is that
1263
# actually useful?
1264
# Not especially, but it's part of the contract.
1265
result_branch = result.create_branch()
1266
else:
1267
result_branch = source_branch.sprout(result,
1268
revision_id=revision_id, repository_policy=repository_policy)
1269
mutter("created new branch %r" % (result_branch,))
1270
1271
# Create/update the result working tree
1272
if (create_tree_if_local and
1273
isinstance(target_transport, local.LocalTransport) and
1274
(result_repo is None or result_repo.make_working_trees())):
1275
wt = result.create_workingtree(accelerator_tree=accelerator_tree,
1276
hardlink=hardlink)
1277
wt.lock_write()
1278
try:
1279
if wt.path2id('') is None:
1280
try:
1281
wt.set_root_id(self.open_workingtree.get_root_id())
1282
except errors.NoWorkingTree:
1283
pass
1284
finally:
1285
wt.unlock()
1286
else:
1287
wt = None
1288
if recurse == 'down':
1289
if wt is not None:
1290
basis = wt.basis_tree()
1291
basis.lock_read()
1292
subtrees = basis.iter_references()
1293
elif result_branch is not None:
1294
basis = result_branch.basis_tree()
1295
basis.lock_read()
1296
subtrees = basis.iter_references()
1297
elif source_branch is not None:
1298
basis = source_branch.basis_tree()
1299
basis.lock_read()
1300
subtrees = basis.iter_references()
1301
else:
1302
subtrees = []
1303
basis = None
1304
try:
1305
for path, file_id in subtrees:
1306
target = urlutils.join(url, urlutils.escape(path))
1307
sublocation = source_branch.reference_parent(file_id, path)
1308
sublocation.bzrdir.sprout(target,
1309
basis.get_reference_revision(file_id, path),
1310
force_new_repo=force_new_repo, recurse=recurse,
1311
stacked=stacked)
1312
finally:
1313
if basis is not None:
1314
basis.unlock()
1315
return result
1316
1317
def push_branch(self, source, revision_id=None, overwrite=False,
1318
remember=False, create_prefix=False):
1319
"""Push the source branch into this BzrDir."""
1320
br_to = None
1321
# If we can open a branch, use its direct repository, otherwise see
1322
# if there is a repository without a branch.
1323
try:
1324
br_to = self.open_branch()
1325
except errors.NotBranchError:
1326
# Didn't find a branch, can we find a repository?
1327
repository_to = self.find_repository()
1328
else:
1329
# Found a branch, so we must have found a repository
1330
repository_to = br_to.repository
1331
1332
push_result = PushResult()
1333
push_result.source_branch = source
1334
if br_to is None:
1335
# We have a repository but no branch, copy the revisions, and then
1336
# create a branch.
1337
repository_to.fetch(source.repository, revision_id=revision_id)
1338
br_to = source.clone(self, revision_id=revision_id)
1339
if source.get_push_location() is None or remember:
1340
source.set_push_location(br_to.base)
1341
push_result.stacked_on = None
1342
push_result.branch_push_result = None
1343
push_result.old_revno = None
1344
push_result.old_revid = _mod_revision.NULL_REVISION
1345
push_result.target_branch = br_to
1346
push_result.master_branch = None
1347
push_result.workingtree_updated = False
1348
else:
1349
# We have successfully opened the branch, remember if necessary:
1350
if source.get_push_location() is None or remember:
1351
source.set_push_location(br_to.base)
1352
try:
1353
tree_to = self.open_workingtree()
1354
except errors.NotLocalUrl:
1355
push_result.branch_push_result = source.push(br_to,
1356
overwrite, stop_revision=revision_id)
1357
push_result.workingtree_updated = False
1358
except errors.NoWorkingTree:
1359
push_result.branch_push_result = source.push(br_to,
1360
overwrite, stop_revision=revision_id)
1361
push_result.workingtree_updated = None # Not applicable
1362
else:
1363
tree_to.lock_write()
1364
try:
1365
push_result.branch_push_result = source.push(
1366
tree_to.branch, overwrite, stop_revision=revision_id)
1367
tree_to.update()
1368
finally:
1369
tree_to.unlock()
1370
push_result.workingtree_updated = True
1371
push_result.old_revno = push_result.branch_push_result.old_revno
1372
push_result.old_revid = push_result.branch_push_result.old_revid
1373
push_result.target_branch = \
1374
push_result.branch_push_result.target_branch
1375
return push_result
1376
1377
1000
1378
1001
class BzrDirHooks(hooks.Hooks):
1379
1002
"""Hooks for BzrDir operations."""
Loggerhead is a web-based interface for Breezy
Version: 2.0.1