258
236
t = _mod_transport.get_transport(url)
262
def find_bzrdirs(transport, evaluate=None, list_current=None):
263
"""Find bzrdirs recursively from current location.
265
This is intended primarily as a building block for more sophisticated
266
functionality, like finding trees under a directory, or finding
267
branches that use a given repository.
269
:param evaluate: An optional callable that yields recurse, value,
270
where recurse controls whether this bzrdir is recursed into
271
and value is the value to yield. By default, all bzrdirs
272
are recursed into, and the return value is the bzrdir.
273
:param list_current: if supplied, use this function to list the current
274
directory, instead of Transport.list_dir
275
:return: a generator of found bzrdirs, or whatever evaluate returns.
277
if list_current is None:
278
def list_current(transport):
279
return transport.list_dir('')
281
def evaluate(bzrdir):
284
pending = [transport]
285
while len(pending) > 0:
286
current_transport = pending.pop()
289
bzrdir = BzrDir.open_from_transport(current_transport)
290
except (errors.NotBranchError, errors.PermissionDenied):
293
recurse, value = evaluate(bzrdir)
296
subdirs = list_current(current_transport)
297
except (errors.NoSuchFile, errors.PermissionDenied):
300
for subdir in sorted(subdirs, reverse=True):
301
pending.append(current_transport.clone(subdir))
304
def find_branches(transport):
305
"""Find all branches under a transport.
307
This will find all branches below the transport, including branches
308
inside other branches. Where possible, it will use
309
Repository.find_branches.
311
To list all the branches that use a particular Repository, see
312
Repository.find_branches
314
def evaluate(bzrdir):
316
repository = bzrdir.open_repository()
317
except errors.NoRepositoryPresent:
320
return False, ([], repository)
321
return True, (bzrdir.list_branches(), None)
323
for branches, repo in BzrDir.find_bzrdirs(transport,
326
ret.extend(repo.find_branches())
327
if branches is not None:
332
def create_branch_and_repo(base, force_new_repo=False, format=None):
333
"""Create a new BzrDir, Branch and Repository at the url 'base'.
335
This will use the current default BzrDirFormat unless one is
336
specified, and use whatever
337
repository format that that uses via bzrdir.create_branch and
338
create_repository. If a shared repository is available that is used
341
The created Branch object is returned.
343
:param base: The URL to create the branch at.
344
:param force_new_repo: If True a new repository is always created.
345
:param format: If supplied, the format of branch to create. If not
346
supplied, the default is used.
348
bzrdir = BzrDir.create(base, format)
349
bzrdir._find_or_create_repository(force_new_repo)
350
return bzrdir.create_branch()
352
239
def determine_repository_policy(self, force_new_repo=False, stack_on=None,
353
240
stack_on_pwd=None, require_stacking=False):
354
241
"""Return an object representing a policy to use.
575
def create_branch_convenience(base, force_new_repo=False,
576
force_new_tree=None, format=None,
577
possible_transports=None):
578
"""Create a new BzrDir, Branch and Repository at the url 'base'.
580
This is a convenience function - it will use an existing repository
581
if possible, can be told explicitly whether to create a working tree or
584
This will use the current default BzrDirFormat unless one is
585
specified, and use whatever
586
repository format that that uses via bzrdir.create_branch and
587
create_repository. If a shared repository is available that is used
588
preferentially. Whatever repository is used, its tree creation policy
591
The created Branch object is returned.
592
If a working tree cannot be made due to base not being a file:// url,
593
no error is raised unless force_new_tree is True, in which case no
594
data is created on disk and NotLocalUrl is raised.
596
:param base: The URL to create the branch at.
597
:param force_new_repo: If True a new repository is always created.
598
:param force_new_tree: If True or False force creation of a tree or
599
prevent such creation respectively.
600
:param format: Override for the bzrdir format to create.
601
:param possible_transports: An optional reusable transports list.
604
# check for non local urls
605
t = _mod_transport.get_transport(base, possible_transports)
606
if not isinstance(t, local.LocalTransport):
607
raise errors.NotLocalUrl(base)
608
bzrdir = BzrDir.create(base, format, possible_transports)
609
repo = bzrdir._find_or_create_repository(force_new_repo)
610
result = bzrdir.create_branch()
611
if force_new_tree or (repo.make_working_trees() and
612
force_new_tree is None):
614
bzrdir.create_workingtree()
615
except errors.NotLocalUrl:
620
def create_standalone_workingtree(base, format=None):
621
"""Create a new BzrDir, WorkingTree, Branch and Repository at 'base'.
623
'base' must be a local path or a file:// url.
625
This will use the current default BzrDirFormat unless one is
626
specified, and use whatever
627
repository format that that uses for bzrdirformat.create_workingtree,
628
create_branch and create_repository.
630
:param format: Override for the bzrdir format to create.
631
:return: The WorkingTree object.
633
t = _mod_transport.get_transport(base)
634
if not isinstance(t, local.LocalTransport):
635
raise errors.NotLocalUrl(base)
636
bzrdir = BzrDir.create_branch_and_repo(base,
638
format=format).bzrdir
639
return bzrdir.create_workingtree()
641
@deprecated_method(deprecated_in((2, 3, 0)))
642
def generate_backup_name(self, base):
643
return self._available_backup_name(base)
645
469
def _available_backup_name(self, base):
646
470
"""Find a non-existing backup file name based on base.
839
664
# add new tests for it to the appropriate place.
840
665
return filename == '.bzr' or filename.startswith('.bzr/')
843
def open_unsupported(base):
844
"""Open a branch which is not supported."""
845
return BzrDir.open(base, _unsupported=True)
848
def open(base, _unsupported=False, possible_transports=None):
849
"""Open an existing bzrdir, rooted at 'base' (url).
851
:param _unsupported: a private parameter to the BzrDir class.
853
t = _mod_transport.get_transport(base, possible_transports)
854
return BzrDir.open_from_transport(t, _unsupported=_unsupported)
857
def open_from_transport(transport, _unsupported=False,
858
_server_formats=True):
859
"""Open a bzrdir within a particular directory.
861
:param transport: Transport containing the bzrdir.
862
:param _unsupported: private.
864
for hook in BzrDir.hooks['pre_open']:
866
# Keep initial base since 'transport' may be modified while following
868
base = transport.base
869
def find_format(transport):
870
return transport, controldir.ControlDirFormat.find_format(
871
transport, _server_formats=_server_formats)
873
def redirected(transport, e, redirection_notice):
874
redirected_transport = transport._redirected_to(e.source, e.target)
875
if redirected_transport is None:
876
raise errors.NotBranchError(base)
877
note('%s is%s redirected to %s',
878
transport.base, e.permanently, redirected_transport.base)
879
return redirected_transport
882
transport, format = do_catching_redirections(find_format,
885
except errors.TooManyRedirections:
886
raise errors.NotBranchError(base)
888
format.check_support_status(_unsupported)
889
return format.open(transport, _found=True)
892
def open_containing(url, possible_transports=None):
893
"""Open an existing branch which contains url.
895
:param url: url to search from.
897
See open_containing_from_transport for more detail.
899
transport = _mod_transport.get_transport(url, possible_transports)
900
return BzrDir.open_containing_from_transport(transport)
903
def open_containing_from_transport(a_transport):
904
"""Open an existing branch which contains a_transport.base.
906
This probes for a branch at a_transport, and searches upwards from there.
908
Basically we keep looking up until we find the control directory or
909
run into the root. If there isn't one, raises NotBranchError.
910
If there is one and it is either an unrecognised format or an unsupported
911
format, UnknownFormatError or UnsupportedFormatError are raised.
912
If there is one, it is returned, along with the unused portion of url.
914
:return: The BzrDir that contains the path, and a Unicode path
915
for the rest of the URL.
917
# this gets the normalised url back. I.e. '.' -> the full path.
918
url = a_transport.base
921
result = BzrDir.open_from_transport(a_transport)
922
return result, urlutils.unescape(a_transport.relpath(url))
923
except errors.NotBranchError, e:
926
new_t = a_transport.clone('..')
927
except errors.InvalidURLJoin:
928
# reached the root, whatever that may be
929
raise errors.NotBranchError(path=url)
930
if new_t.base == a_transport.base:
931
# reached the root, whatever that may be
932
raise errors.NotBranchError(path=url)
936
def open_tree_or_branch(klass, location):
937
"""Return the branch and working tree at a location.
939
If there is no tree at the location, tree will be None.
940
If there is no branch at the location, an exception will be
942
:return: (tree, branch)
944
bzrdir = klass.open(location)
945
return bzrdir._get_tree_branch()
948
def open_containing_tree_or_branch(klass, location):
949
"""Return the branch and working tree contained by a location.
951
Returns (tree, branch, relpath).
952
If there is no tree at containing the location, tree will be None.
953
If there is no branch containing the location, an exception will be
955
relpath is the portion of the path that is contained by the branch.
957
bzrdir, relpath = klass.open_containing(location)
958
tree, branch = bzrdir._get_tree_branch()
959
return tree, branch, relpath
962
def open_containing_tree_branch_or_repository(klass, location):
963
"""Return the working tree, branch and repo contained by a location.
965
Returns (tree, branch, repository, relpath).
966
If there is no tree containing the location, tree will be None.
967
If there is no branch containing the location, branch will be None.
968
If there is no repository containing the location, repository will be
970
relpath is the portion of the path that is contained by the innermost
973
If no tree, branch or repository is found, a NotBranchError is raised.
975
bzrdir, relpath = klass.open_containing(location)
977
tree, branch = bzrdir._get_tree_branch()
978
except errors.NotBranchError:
980
repo = bzrdir.find_repository()
981
return None, None, repo, relpath
982
except (errors.NoRepositoryPresent):
983
raise errors.NotBranchError(location)
984
return tree, branch, branch.repository, relpath
986
667
def _cloning_metadir(self):
987
668
"""Produce a metadir suitable for cloning with.
1104
767
raise NotImplementedError(self.get_workingtree_transport)
1107
class BzrDirHooks(hooks.Hooks):
1108
"""Hooks for BzrDir operations."""
1111
"""Create the default hooks."""
1112
hooks.Hooks.__init__(self, "bzrlib.bzrdir", "BzrDir.hooks")
1113
self.add_hook('pre_open',
1114
"Invoked before attempting to open a BzrDir with the transport "
1115
"that the open will use.", (1, 14))
1116
self.add_hook('post_repo_init',
1117
"Invoked after a repository has been initialized. "
1118
"post_repo_init is called with a "
1119
"bzrlib.bzrdir.RepoInitHookParams.",
1122
# install the default hooks
1123
BzrDir.hooks = BzrDirHooks()
1126
class RepoInitHookParams(object):
1127
"""Object holding parameters passed to `*_repo_init` hooks.
1129
There are 4 fields that hooks may wish to access:
1131
:ivar repository: Repository created
1132
:ivar format: Repository format
1133
:ivar bzrdir: The bzrdir for the repository
1134
:ivar shared: The repository is shared
1137
def __init__(self, repository, format, a_bzrdir, shared):
1138
"""Create a group of RepoInitHook parameters.
1140
:param repository: Repository created
1141
:param format: Repository format
1142
:param bzrdir: The bzrdir for the repository
1143
:param shared: The repository is shared
770
def create(cls, base, format=None, possible_transports=None):
771
"""Create a new BzrDir at the url 'base'.
773
:param format: If supplied, the format of branch to create. If not
774
supplied, the default is used.
775
:param possible_transports: If supplied, a list of transports that
776
can be reused to share a remote connection.
1145
self.repository = repository
1146
self.format = format
1147
self.bzrdir = a_bzrdir
1148
self.shared = shared
1150
def __eq__(self, other):
1151
return self.__dict__ == other.__dict__
778
if cls is not BzrDir:
779
raise AssertionError("BzrDir.create always creates the "
780
"default format, not one of %r" % cls)
781
return controldir.ControlDir.create(base, format=format,
782
possible_transports=possible_transports)
1153
784
def __repr__(self):
1155
return "<%s for %s>" % (self.__class__.__name__,
1158
return "<%s for %s>" % (self.__class__.__name__,
785
return "<%s at %r>" % (self.__class__.__name__, self.user_url)
787
def update_feature_flags(self, updated_flags):
788
"""Update the features required by this bzrdir.
790
:param updated_flags: Dictionary mapping feature names to necessities
791
A necessity can be None to indicate the feature should be removed
793
self.control_files.lock_write()
795
self._format._update_feature_flags(updated_flags)
796
self.transport.put_bytes('branch-format', self._format.as_string())
798
self.control_files.unlock()
1162
801
class BzrDirMeta1(BzrDir):
1168
807
present within a BzrDir.
810
def _get_branch_path(self, name):
811
"""Obtain the branch path to use.
813
This uses the API specified branch name first, and then falls back to
814
the branch name specified in the URL. If neither of those is specified,
815
it uses the default branch.
817
:param name: Optional branch name to use
818
:return: Relative path to branch
822
return urlutils.join('branches', name.encode("utf-8"))
824
def _read_branch_list(self):
825
"""Read the branch list.
827
:return: List of utf-8 encoded branch names.
830
f = self.control_transport.get('branch-list')
831
except errors.NoSuchFile:
837
ret.append(name.rstrip("\n"))
842
def _write_branch_list(self, branches):
843
"""Write out the branch list.
845
:param branches: List of utf-8 branch names to write
847
self.transport.put_bytes('branch-list',
848
"".join([name+"\n" for name in branches]))
850
def __init__(self, _transport, _format):
851
super(BzrDirMeta1, self).__init__(_transport, _format)
852
self.control_files = lockable_files.LockableFiles(
853
self.control_transport, self._format._lock_file_name,
854
self._format._lock_class)
1171
856
def can_convert_format(self):
1172
857
"""See BzrDir.can_convert_format()."""
1175
def create_branch(self, name=None, repository=None):
1176
"""See BzrDir.create_branch."""
860
def create_branch(self, name=None, repository=None,
861
append_revisions_only=None):
862
"""See ControlDir.create_branch."""
864
name = self._get_selected_branch()
1177
865
return self._format.get_branch_format().initialize(self, name=name,
1178
repository=repository)
866
repository=repository,
867
append_revisions_only=append_revisions_only)
1180
869
def destroy_branch(self, name=None):
1181
"""See BzrDir.create_branch."""
1182
if name is not None:
1183
raise errors.NoColocatedBranchSupport(self)
1184
self.transport.delete_tree('branch')
870
"""See ControlDir.destroy_branch."""
872
name = self._get_selected_branch()
873
path = self._get_branch_path(name)
875
self.control_files.lock_write()
877
branches = self._read_branch_list()
879
branches.remove(name.encode("utf-8"))
881
raise errors.NotBranchError(name)
882
self._write_branch_list(branches)
884
self.control_files.unlock()
886
self.transport.delete_tree(path)
887
except errors.NoSuchFile:
888
raise errors.NotBranchError(path=urlutils.join(self.transport.base,
1186
891
def create_repository(self, shared=False):
1187
892
"""See BzrDir.create_repository."""
1229
937
def get_branch_reference(self, name=None):
1230
938
"""See BzrDir.get_branch_reference()."""
1231
from bzrlib.branch import BranchFormat
1232
format = BranchFormat.find_format(self, name=name)
939
from bzrlib.branch import BranchFormatMetadir
940
format = BranchFormatMetadir.find_format(self, name=name)
1233
941
return format.get_reference(self, name=name)
943
def set_branch_reference(self, target_branch, name=None):
944
format = _mod_branch.BranchReferenceFormat()
945
return format.initialize(self, target_branch=target_branch, name=name)
1235
947
def get_branch_transport(self, branch_format, name=None):
1236
948
"""See BzrDir.get_branch_transport()."""
1237
if name is not None:
1238
raise errors.NoColocatedBranchSupport(self)
950
name = self._get_selected_branch()
951
path = self._get_branch_path(name)
1239
952
# XXX: this shouldn't implicitly create the directory if it's just
1240
953
# promising to get a transport -- mbp 20090727
1241
954
if branch_format is None:
1242
return self.transport.clone('branch')
955
return self.transport.clone(path)
1244
957
branch_format.get_format_string()
1245
958
except NotImplementedError:
1246
959
raise errors.IncompatibleFormat(branch_format, self._format)
961
branches = self._read_branch_list()
962
utf8_name = name.encode("utf-8")
963
if not utf8_name in branches:
964
self.control_files.lock_write()
966
branches = self._read_branch_list()
967
dirname = urlutils.dirname(utf8_name)
968
if dirname != "" and dirname in branches:
969
raise errors.ParentBranchExists(name)
971
b.startswith(utf8_name+"/") for b in branches]
972
if any(child_branches):
973
raise errors.AlreadyBranchError(name)
974
branches.append(utf8_name)
975
self._write_branch_list(branches)
977
self.control_files.unlock()
978
branch_transport = self.transport.clone(path)
979
mode = self._get_mkdir_mode()
980
branch_transport.create_prefix(mode=mode)
1248
self.transport.mkdir('branch', mode=self._get_mkdir_mode())
982
self.transport.mkdir(path, mode=mode)
1249
983
except errors.FileExists:
1251
return self.transport.clone('branch')
985
return self.transport.clone(path)
1253
987
def get_repository_transport(self, repository_format):
1254
988
"""See BzrDir.get_repository_transport()."""
1279
1013
return self.transport.clone('checkout')
1015
def get_branches(self):
1016
"""See ControlDir.get_branches."""
1019
ret[""] = self.open_branch(name="")
1020
except (errors.NotBranchError, errors.NoRepositoryPresent):
1023
for name in self._read_branch_list():
1024
ret[name] = self.open_branch(name=name.decode('utf-8'))
1281
1028
def has_workingtree(self):
1282
1029
"""Tell if this bzrdir contains a working tree.
1284
1031
Note: if you're going to open the working tree, you should just go
1285
1032
ahead and try, and not ask permission first.
1287
from bzrlib.workingtree import WorkingTreeFormat
1034
from bzrlib.workingtree import WorkingTreeFormatMetaDir
1289
WorkingTreeFormat.find_format_string(self)
1036
WorkingTreeFormatMetaDir.find_format_string(self)
1290
1037
except errors.NoWorkingTree:
1294
1041
def needs_format_conversion(self, format):
1295
1042
"""See BzrDir.needs_format_conversion()."""
1296
if not isinstance(self._format, format.__class__):
1043
if (not isinstance(self._format, format.__class__) or
1044
self._format.get_format_string() != format.get_format_string()):
1297
1045
# it is not a meta dir format, conversion is needed.
1299
1047
# we might want to push this down to the repository?
1322
1070
def open_branch(self, name=None, unsupported=False,
1323
ignore_fallbacks=False):
1324
"""See BzrDir.open_branch."""
1071
ignore_fallbacks=False, possible_transports=None):
1072
"""See ControlDir.open_branch."""
1074
name = self._get_selected_branch()
1325
1075
format = self.find_branch_format(name=name)
1326
1076
format.check_support_status(unsupported)
1327
1077
return format.open(self, name=name,
1328
_found=True, ignore_fallbacks=ignore_fallbacks)
1078
_found=True, ignore_fallbacks=ignore_fallbacks,
1079
possible_transports=possible_transports)
1330
1081
def open_repository(self, unsupported=False):
1331
1082
"""See BzrDir.open_repository."""
1332
from bzrlib.repository import RepositoryFormat
1333
format = RepositoryFormat.find_format(self)
1083
from bzrlib.repository import RepositoryFormatMetaDir
1084
format = RepositoryFormatMetaDir.find_format(self)
1334
1085
format.check_support_status(unsupported)
1335
1086
return format.open(self, _found=True)
1337
1088
def open_workingtree(self, unsupported=False,
1338
1089
recommend_upgrade=True):
1339
1090
"""See BzrDir.open_workingtree."""
1340
from bzrlib.workingtree import WorkingTreeFormat
1341
format = WorkingTreeFormat.find_format(self)
1091
from bzrlib.workingtree import WorkingTreeFormatMetaDir
1092
format = WorkingTreeFormatMetaDir.find_format(self)
1342
1093
format.check_support_status(unsupported, recommend_upgrade,
1343
1094
basedir=self.root_transport.base)
1344
1095
return format.open(self, _found=True)
1347
1098
return config.TransportConfig(self.transport, 'control.conf')
1101
class BzrFormat(object):
1102
"""Base class for all formats of things living in metadirs.
1104
This class manages the format string that is stored in the 'format'
1105
or 'branch-format' file.
1107
All classes for (branch-, repository-, workingtree-) formats that
1108
live in meta directories and have their own 'format' file
1109
(i.e. different from .bzr/branch-format) derive from this class,
1110
as well as the relevant base class for their kind
1111
(BranchFormat, WorkingTreeFormat, RepositoryFormat).
1113
Each format is identified by a "format" or "branch-format" file with a
1114
single line containing the base format name and then an optional list of
1117
Feature flags are supported as of bzr 2.5. Setting feature flags on formats
1118
will render them inaccessible to older versions of bzr.
1120
:ivar features: Dictionary mapping feature names to their necessity
1123
_present_features = set()
1129
def register_feature(cls, name):
1130
"""Register a feature as being present.
1132
:param name: Name of the feature
1135
raise ValueError("spaces are not allowed in feature names")
1136
if name in cls._present_features:
1137
raise errors.FeatureAlreadyRegistered(name)
1138
cls._present_features.add(name)
1141
def unregister_feature(cls, name):
1142
"""Unregister a feature."""
1143
cls._present_features.remove(name)
1145
def check_support_status(self, allow_unsupported, recommend_upgrade=True,
1147
for name, necessity in self.features.iteritems():
1148
if name in self._present_features:
1150
if necessity == "optional":
1151
mutter("ignoring optional missing feature %s", name)
1153
elif necessity == "required":
1154
raise errors.MissingFeature(name)
1156
mutter("treating unknown necessity as require for %s",
1158
raise errors.MissingFeature(name)
1161
def get_format_string(cls):
1162
"""Return the ASCII format string that identifies this format."""
1163
raise NotImplementedError(cls.get_format_string)
1166
def from_string(cls, text):
1167
format_string = cls.get_format_string()
1168
if not text.startswith(format_string):
1169
raise AssertionError("Invalid format header %r for %r" % (text, cls))
1170
lines = text[len(format_string):].splitlines()
1172
for lineno, line in enumerate(lines):
1174
(necessity, feature) = line.split(" ", 1)
1176
raise errors.ParseFormatError(format=cls, lineno=lineno+2,
1177
line=line, text=text)
1178
ret.features[feature] = necessity
1181
def as_string(self):
1182
"""Return the string representation of this format.
1184
lines = [self.get_format_string()]
1185
lines.extend([("%s %s\n" % (item[1], item[0])) for item in
1186
self.features.iteritems()])
1187
return "".join(lines)
1190
def _find_format(klass, registry, kind, format_string):
1192
first_line = format_string[:format_string.index("\n")+1]
1194
first_line = format_string
1196
cls = registry.get(first_line)
1198
raise errors.UnknownFormatError(format=first_line, kind=kind)
1199
return cls.from_string(format_string)
1201
def network_name(self):
1202
"""A simple byte string uniquely identifying this format for RPC calls.
1204
Metadir branch formats use their format string.
1206
return self.as_string()
1208
def __eq__(self, other):
1209
return (self.__class__ is other.__class__ and
1210
self.features == other.features)
1212
def _update_feature_flags(self, updated_flags):
1213
"""Update the feature flags in this format.
1215
:param updated_flags: Updated feature flags
1217
for name, necessity in updated_flags.iteritems():
1218
if necessity is None:
1220
del self.features[name]
1224
self.features[name] = necessity
1350
1227
class BzrProber(controldir.Prober):
1351
1228
"""Prober for formats that use a .bzr/ control directory."""
1354
1231
"""The known .bzr formats."""
1357
@deprecated_method(deprecated_in((2, 4, 0)))
1358
def register_bzrdir_format(klass, format):
1359
klass.formats.register(format.get_format_string(), format)
1362
@deprecated_method(deprecated_in((2, 4, 0)))
1363
def unregister_bzrdir_format(klass, format):
1364
klass.formats.remove(format.get_format_string())
1367
1234
def probe_transport(klass, transport):
1368
1235
"""Return the .bzrdir style format present in a directory."""
1370
1237
format_string = transport.get_bytes(".bzr/branch-format")
1371
1238
except errors.NoSuchFile:
1372
1239
raise errors.NotBranchError(path=transport.base)
1373
format_string = extract_format_string(format_string)
1375
return klass.formats.get(format_string)
1241
first_line = format_string[:format_string.index("\n")+1]
1243
first_line = format_string
1245
cls = klass.formats.get(first_line)
1376
1246
except KeyError:
1377
raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
1247
raise errors.UnknownFormatError(format=first_line, kind='bzrdir')
1248
return cls.from_string(format_string)
1380
1251
def known_formats(cls):
1856
1750
controldir.ControlDirFormat._default_format = BzrDirMetaFormat1()
1753
class BzrDirMetaFormat1Colo(BzrDirMetaFormat1):
1754
"""BzrDirMeta1 format with support for colocated branches."""
1756
colocated_branches = True
1759
def get_format_string(cls):
1760
"""See BzrDirFormat.get_format_string()."""
1761
return "Bazaar meta directory, format 1 (with colocated branches)\n"
1763
def get_format_description(self):
1764
"""See BzrDirFormat.get_format_description()."""
1765
return "Meta directory format 1 with support for colocated branches"
1767
def _open(self, transport):
1768
"""See BzrDirFormat._open."""
1769
# Create a new format instance because otherwise initialisation of new
1770
# metadirs share the global default format object leading to alias
1772
format = BzrDirMetaFormat1Colo()
1773
self._supply_sub_formats_to(format)
1774
return BzrDirMeta1(transport, format)
1777
BzrProber.formats.register(BzrDirMetaFormat1Colo.get_format_string(),
1778
BzrDirMetaFormat1Colo)
1859
1781
class ConvertMetaToMeta(controldir.Converter):
1860
1782
"""Converts the components of metadirs."""
1934
1856
return to_convert
1859
class ConvertMetaToColo(controldir.Converter):
1860
"""Add colocated branch support."""
1862
def __init__(self, target_format):
1863
"""Create a converter.that upgrades a metadir to the colo format.
1865
:param target_format: The final metadir format that is desired.
1867
self.target_format = target_format
1869
def convert(self, to_convert, pb):
1870
"""See Converter.convert()."""
1871
to_convert.transport.put_bytes('branch-format',
1872
self.target_format.as_string())
1873
return BzrDir.open_from_transport(to_convert.root_transport)
1876
class ConvertMetaToColo(controldir.Converter):
1877
"""Convert a 'development-colo' bzrdir to a '2a' bzrdir."""
1879
def __init__(self, target_format):
1880
"""Create a converter that converts a 'development-colo' metadir
1883
:param target_format: The final metadir format that is desired.
1885
self.target_format = target_format
1887
def convert(self, to_convert, pb):
1888
"""See Converter.convert()."""
1889
to_convert.transport.put_bytes('branch-format',
1890
self.target_format.as_string())
1891
return BzrDir.open_from_transport(to_convert.root_transport)
1937
1894
controldir.ControlDirFormat.register_server_prober(RemoteBzrProber)
2047
2005
require_stacking)
2048
2006
self._bzrdir = bzrdir
2050
def acquire_repository(self, make_working_trees=None, shared=False):
2008
def acquire_repository(self, make_working_trees=None, shared=False,
2009
possible_transports=None):
2051
2010
"""Implementation of RepositoryAcquisitionPolicy.acquire_repository
2053
2012
Creates the desired repository in the bzrdir we already have.
2014
if possible_transports is None:
2015
possible_transports = []
2017
possible_transports = list(possible_transports)
2018
possible_transports.append(self._bzrdir.root_transport)
2055
2019
stack_on = self._get_full_stack_on()
2057
2021
format = self._bzrdir._format
2058
2022
format.require_stacking(stack_on=stack_on,
2059
possible_transports=[self._bzrdir.root_transport])
2023
possible_transports=possible_transports)
2060
2024
if not self._require_stacking:
2061
2025
# We have picked up automatic stacking somewhere.
2062
note('Using default stacking branch %s at %s', self._stack_on,
2026
note(gettext('Using default stacking branch {0} at {1}').format(
2027
self._stack_on, self._stack_on_pwd))
2064
2028
repository = self._bzrdir.create_repository(shared=shared)
2065
2029
self._add_fallback(repository,
2066
possible_transports=[self._bzrdir.transport])
2030
possible_transports=possible_transports)
2067
2031
if make_working_trees is not None:
2068
2032
repository.set_make_working_trees(make_working_trees)
2069
2033
return repository, True
2142
2114
register_metadir(controldir.format_registry, 'knit',
2143
2115
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
2144
2116
'Format using knits. Recommended for interoperation with bzr <= 0.14.',
2145
branch_format='bzrlib.branch.BzrBranchFormat5',
2117
branch_format='bzrlib.branchfmt.fullhistory.BzrBranchFormat5',
2146
2118
tree_format='bzrlib.workingtree_3.WorkingTreeFormat3',
2148
2120
deprecated=True)
2149
2121
register_metadir(controldir.format_registry, 'dirstate',
2150
2122
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
2151
help='New in 0.15: Fast local operations. Compatible with bzr 0.8 and '
2152
'above when accessed over the network.',
2153
branch_format='bzrlib.branch.BzrBranchFormat5',
2123
help='Format using dirstate for working trees. '
2124
'Compatible with bzr 0.8 and '
2125
'above when accessed over the network. Introduced in bzr 0.15.',
2126
branch_format='bzrlib.branchfmt.fullhistory.BzrBranchFormat5',
2154
2127
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2156
2129
deprecated=True)
2157
2130
register_metadir(controldir.format_registry, 'dirstate-tags',
2158
2131
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
2159
help='New in 0.15: Fast local operations and improved scaling for '
2160
'network operations. Additionally adds support for tags.'
2161
' Incompatible with bzr < 0.15.',
2132
help='Variant of dirstate with support for tags. '
2133
'Introduced in bzr 0.15.',
2162
2134
branch_format='bzrlib.branch.BzrBranchFormat6',
2163
2135
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2165
2137
deprecated=True)
2166
2138
register_metadir(controldir.format_registry, 'rich-root',
2167
2139
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit4',
2168
help='New in 1.0. Better handling of tree roots. Incompatible with'
2140
help='Variant of dirstate with better handling of tree roots. '
2141
'Introduced in bzr 1.0',
2170
2142
branch_format='bzrlib.branch.BzrBranchFormat6',
2171
2143
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2173
2145
deprecated=True)
2174
2146
register_metadir(controldir.format_registry, 'dirstate-with-subtree',
2175
2147
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
2176
help='New in 0.15: Fast local operations and improved scaling for '
2177
'network operations. Additionally adds support for versioning nested '
2178
'bzr branches. Incompatible with bzr < 0.15.',
2148
help='Variant of dirstate with support for nested trees. '
2149
'Introduced in 0.15.',
2179
2150
branch_format='bzrlib.branch.BzrBranchFormat6',
2180
2151
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2181
2152
experimental=True,
2184
2155
register_metadir(controldir.format_registry, 'pack-0.92',
2185
2156
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack1',
2186
help='New in 0.92: Pack-based format with data compatible with '
2187
'dirstate-tags format repositories. Interoperates with '
2188
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
2157
help='Pack-based format used in 1.x series. Introduced in 0.92. '
2158
'Interoperates with bzr repositories before 0.92 but cannot be '
2159
'read by bzr < 0.92. '
2190
2161
branch_format='bzrlib.branch.BzrBranchFormat6',
2191
2162
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2193
2165
register_metadir(controldir.format_registry, 'pack-0.92-subtree',
2194
2166
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack3',
2195
help='New in 0.92: Pack-based format with data compatible with '
2196
'dirstate-with-subtree format repositories. Interoperates with '
2167
help='Pack-based format used in 1.x series, with subtree support. '
2168
'Introduced in 0.92. Interoperates with '
2197
2169
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
2199
2171
branch_format='bzrlib.branch.BzrBranchFormat6',
2200
2172
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2202
2175
experimental=True,
2204
2177
register_metadir(controldir.format_registry, 'rich-root-pack',
2205
2178
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack4',
2206
help='New in 1.0: A variant of pack-0.92 that supports rich-root data '
2207
'(needed for bzr-svn and bzr-git).',
2179
help='A variant of pack-0.92 that supports rich-root data '
2180
'(needed for bzr-svn and bzr-git). Introduced in 1.0.',
2208
2181
branch_format='bzrlib.branch.BzrBranchFormat6',
2209
2182
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2212
2186
register_metadir(controldir.format_registry, '1.6',
2213
2187
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack5',
2273
register_metadir(controldir.format_registry, 'development-colo',
2274
'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
2275
help='The 2a format with experimental support for colocated branches.\n',
2276
branch_format='bzrlib.branch.BzrBranchFormat7',
2277
tree_format='bzrlib.workingtree_4.WorkingTreeFormat6',
2279
bzrdir_format=BzrDirMetaFormat1Colo,
2291
2283
# And the development formats above will have aliased one of the following:
2293
2285
# Finally, the current format.
2294
2286
register_metadir(controldir.format_registry, '2a',
2295
2287
'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
2296
help='First format for bzr 2.0 series.\n'
2288
help='Format for the bzr 2.0 series.\n'
2297
2289
'Uses group-compress storage.\n'
2298
2290
'Provides rich roots which are a one-way transition.\n',
2299
2291
# 'storage in packs, 255-way hashed CHK inventory, bencode revision, group compress, '
added
removed
bzrlib/bzrdir.py
