232
235
t = _mod_transport.get_transport(url)
236
def find_bzrdirs(transport, evaluate=None, list_current=None):
237
"""Find bzrdirs recursively from current location.
239
This is intended primarily as a building block for more sophisticated
240
functionality, like finding trees under a directory, or finding
241
branches that use a given repository.
243
:param evaluate: An optional callable that yields recurse, value,
244
where recurse controls whether this bzrdir is recursed into
245
and value is the value to yield. By default, all bzrdirs
246
are recursed into, and the return value is the bzrdir.
247
:param list_current: if supplied, use this function to list the current
248
directory, instead of Transport.list_dir
249
:return: a generator of found bzrdirs, or whatever evaluate returns.
251
if list_current is None:
252
def list_current(transport):
253
return transport.list_dir('')
255
def evaluate(bzrdir):
258
pending = [transport]
259
while len(pending) > 0:
260
current_transport = pending.pop()
263
bzrdir = BzrDir.open_from_transport(current_transport)
264
except (errors.NotBranchError, errors.PermissionDenied):
267
recurse, value = evaluate(bzrdir)
270
subdirs = list_current(current_transport)
271
except (errors.NoSuchFile, errors.PermissionDenied):
274
for subdir in sorted(subdirs, reverse=True):
275
pending.append(current_transport.clone(subdir))
278
def find_branches(transport):
279
"""Find all branches under a transport.
281
This will find all branches below the transport, including branches
282
inside other branches. Where possible, it will use
283
Repository.find_branches.
285
To list all the branches that use a particular Repository, see
286
Repository.find_branches
288
def evaluate(bzrdir):
290
repository = bzrdir.open_repository()
291
except errors.NoRepositoryPresent:
294
return False, ([], repository)
295
return True, (bzrdir.list_branches(), None)
297
for branches, repo in BzrDir.find_bzrdirs(transport,
300
ret.extend(repo.find_branches())
301
if branches is not None:
306
def create_branch_and_repo(base, force_new_repo=False, format=None):
307
"""Create a new BzrDir, Branch and Repository at the url 'base'.
309
This will use the current default BzrDirFormat unless one is
310
specified, and use whatever
311
repository format that that uses via bzrdir.create_branch and
312
create_repository. If a shared repository is available that is used
315
The created Branch object is returned.
317
:param base: The URL to create the branch at.
318
:param force_new_repo: If True a new repository is always created.
319
:param format: If supplied, the format of branch to create. If not
320
supplied, the default is used.
322
bzrdir = BzrDir.create(base, format)
323
bzrdir._find_or_create_repository(force_new_repo)
324
return bzrdir.create_branch()
326
238
def determine_repository_policy(self, force_new_repo=False, stack_on=None,
327
239
stack_on_pwd=None, require_stacking=False):
328
240
"""Return an object representing a policy to use.
549
def create_branch_convenience(base, force_new_repo=False,
550
force_new_tree=None, format=None,
551
possible_transports=None):
552
"""Create a new BzrDir, Branch and Repository at the url 'base'.
554
This is a convenience function - it will use an existing repository
555
if possible, can be told explicitly whether to create a working tree or
558
This will use the current default BzrDirFormat unless one is
559
specified, and use whatever
560
repository format that that uses via bzrdir.create_branch and
561
create_repository. If a shared repository is available that is used
562
preferentially. Whatever repository is used, its tree creation policy
565
The created Branch object is returned.
566
If a working tree cannot be made due to base not being a file:// url,
567
no error is raised unless force_new_tree is True, in which case no
568
data is created on disk and NotLocalUrl is raised.
570
:param base: The URL to create the branch at.
571
:param force_new_repo: If True a new repository is always created.
572
:param force_new_tree: If True or False force creation of a tree or
573
prevent such creation respectively.
574
:param format: Override for the bzrdir format to create.
575
:param possible_transports: An optional reusable transports list.
578
# check for non local urls
579
t = _mod_transport.get_transport(base, possible_transports)
580
if not isinstance(t, local.LocalTransport):
581
raise errors.NotLocalUrl(base)
582
bzrdir = BzrDir.create(base, format, possible_transports)
583
repo = bzrdir._find_or_create_repository(force_new_repo)
584
result = bzrdir.create_branch()
585
if force_new_tree or (repo.make_working_trees() and
586
force_new_tree is None):
588
bzrdir.create_workingtree()
589
except errors.NotLocalUrl:
594
def create_standalone_workingtree(base, format=None):
595
"""Create a new BzrDir, WorkingTree, Branch and Repository at 'base'.
597
'base' must be a local path or a file:// url.
599
This will use the current default BzrDirFormat unless one is
600
specified, and use whatever
601
repository format that that uses for bzrdirformat.create_workingtree,
602
create_branch and create_repository.
604
:param format: Override for the bzrdir format to create.
605
:return: The WorkingTree object.
607
t = _mod_transport.get_transport(base)
608
if not isinstance(t, local.LocalTransport):
609
raise errors.NotLocalUrl(base)
610
bzrdir = BzrDir.create_branch_and_repo(base,
612
format=format).bzrdir
613
return bzrdir.create_workingtree()
615
468
@deprecated_method(deprecated_in((2, 3, 0)))
616
469
def generate_backup_name(self, base):
617
470
return self._available_backup_name(base)
814
667
# add new tests for it to the appropriate place.
815
668
return filename == '.bzr' or filename.startswith('.bzr/')
818
def open_unsupported(base):
819
"""Open a branch which is not supported."""
820
return BzrDir.open(base, _unsupported=True)
823
def open(base, _unsupported=False, possible_transports=None):
824
"""Open an existing bzrdir, rooted at 'base' (url).
826
:param _unsupported: a private parameter to the BzrDir class.
828
t = _mod_transport.get_transport(base, possible_transports)
829
return BzrDir.open_from_transport(t, _unsupported=_unsupported)
832
def open_from_transport(transport, _unsupported=False,
833
_server_formats=True):
834
"""Open a bzrdir within a particular directory.
836
:param transport: Transport containing the bzrdir.
837
:param _unsupported: private.
839
for hook in BzrDir.hooks['pre_open']:
841
# Keep initial base since 'transport' may be modified while following
843
base = transport.base
844
def find_format(transport):
845
return transport, controldir.ControlDirFormat.find_format(
846
transport, _server_formats=_server_formats)
848
def redirected(transport, e, redirection_notice):
849
redirected_transport = transport._redirected_to(e.source, e.target)
850
if redirected_transport is None:
851
raise errors.NotBranchError(base)
852
note('%s is%s redirected to %s',
853
transport.base, e.permanently, redirected_transport.base)
854
return redirected_transport
857
transport, format = do_catching_redirections(find_format,
860
except errors.TooManyRedirections:
861
raise errors.NotBranchError(base)
863
format.check_support_status(_unsupported)
864
return format.open(transport, _found=True)
867
def open_containing(url, possible_transports=None):
868
"""Open an existing branch which contains url.
870
:param url: url to search from.
872
See open_containing_from_transport for more detail.
874
transport = _mod_transport.get_transport(url, possible_transports)
875
return BzrDir.open_containing_from_transport(transport)
878
def open_containing_from_transport(a_transport):
879
"""Open an existing branch which contains a_transport.base.
881
This probes for a branch at a_transport, and searches upwards from there.
883
Basically we keep looking up until we find the control directory or
884
run into the root. If there isn't one, raises NotBranchError.
885
If there is one and it is either an unrecognised format or an unsupported
886
format, UnknownFormatError or UnsupportedFormatError are raised.
887
If there is one, it is returned, along with the unused portion of url.
889
:return: The BzrDir that contains the path, and a Unicode path
890
for the rest of the URL.
892
# this gets the normalised url back. I.e. '.' -> the full path.
893
url = a_transport.base
896
result = BzrDir.open_from_transport(a_transport)
897
return result, urlutils.unescape(a_transport.relpath(url))
898
except errors.NotBranchError, e:
901
new_t = a_transport.clone('..')
902
except errors.InvalidURLJoin:
903
# reached the root, whatever that may be
904
raise errors.NotBranchError(path=url)
905
if new_t.base == a_transport.base:
906
# reached the root, whatever that may be
907
raise errors.NotBranchError(path=url)
911
def open_tree_or_branch(klass, location):
912
"""Return the branch and working tree at a location.
914
If there is no tree at the location, tree will be None.
915
If there is no branch at the location, an exception will be
917
:return: (tree, branch)
919
bzrdir = klass.open(location)
920
return bzrdir._get_tree_branch()
923
def open_containing_tree_or_branch(klass, location):
924
"""Return the branch and working tree contained by a location.
926
Returns (tree, branch, relpath).
927
If there is no tree at containing the location, tree will be None.
928
If there is no branch containing the location, an exception will be
930
relpath is the portion of the path that is contained by the branch.
932
bzrdir, relpath = klass.open_containing(location)
933
tree, branch = bzrdir._get_tree_branch()
934
return tree, branch, relpath
937
def open_containing_tree_branch_or_repository(klass, location):
938
"""Return the working tree, branch and repo contained by a location.
940
Returns (tree, branch, repository, relpath).
941
If there is no tree containing the location, tree will be None.
942
If there is no branch containing the location, branch will be None.
943
If there is no repository containing the location, repository will be
945
relpath is the portion of the path that is contained by the innermost
948
If no tree, branch or repository is found, a NotBranchError is raised.
950
bzrdir, relpath = klass.open_containing(location)
952
tree, branch = bzrdir._get_tree_branch()
953
except errors.NotBranchError:
955
repo = bzrdir.find_repository()
956
return None, None, repo, relpath
957
except (errors.NoRepositoryPresent):
958
raise errors.NotBranchError(location)
959
return tree, branch, branch.repository, relpath
961
670
def _cloning_metadir(self):
962
671
"""Produce a metadir suitable for cloning with.
1079
770
raise NotImplementedError(self.get_workingtree_transport)
1082
class BzrDirHooks(hooks.Hooks):
1083
"""Hooks for BzrDir operations."""
1086
"""Create the default hooks."""
1087
hooks.Hooks.__init__(self, "bzrlib.bzrdir", "BzrDir.hooks")
1088
self.add_hook('pre_open',
1089
"Invoked before attempting to open a BzrDir with the transport "
1090
"that the open will use.", (1, 14))
1091
self.add_hook('post_repo_init',
1092
"Invoked after a repository has been initialized. "
1093
"post_repo_init is called with a "
1094
"bzrlib.bzrdir.RepoInitHookParams.",
1097
# install the default hooks
1098
BzrDir.hooks = BzrDirHooks()
1101
class RepoInitHookParams(object):
1102
"""Object holding parameters passed to `*_repo_init` hooks.
1104
There are 4 fields that hooks may wish to access:
1106
:ivar repository: Repository created
1107
:ivar format: Repository format
1108
:ivar bzrdir: The bzrdir for the repository
1109
:ivar shared: The repository is shared
1112
def __init__(self, repository, format, a_bzrdir, shared):
1113
"""Create a group of RepoInitHook parameters.
1115
:param repository: Repository created
1116
:param format: Repository format
1117
:param bzrdir: The bzrdir for the repository
1118
:param shared: The repository is shared
773
def create(cls, base, format=None, possible_transports=None):
774
"""Create a new BzrDir at the url 'base'.
776
:param format: If supplied, the format of branch to create. If not
777
supplied, the default is used.
778
:param possible_transports: If supplied, a list of transports that
779
can be reused to share a remote connection.
1120
self.repository = repository
1121
self.format = format
1122
self.bzrdir = a_bzrdir
1123
self.shared = shared
1125
def __eq__(self, other):
1126
return self.__dict__ == other.__dict__
781
if cls is not BzrDir:
782
raise AssertionError("BzrDir.create always creates the "
783
"default format, not one of %r" % cls)
784
return controldir.ControlDir.create(base, format=format,
785
possible_transports=possible_transports)
1128
787
def __repr__(self):
1130
return "<%s for %s>" % (self.__class__.__name__,
1133
return "<%s for %s>" % (self.__class__.__name__,
788
return "<%s at %r>" % (self.__class__.__name__, self.user_url)
790
def update_feature_flags(self, updated_flags):
791
"""Update the features required by this bzrdir.
793
:param updated_flags: Dictionary mapping feature names to necessities
794
A necessity can be None to indicate the feature should be removed
796
self.control_files.lock_write()
798
self._format._update_feature_flags(updated_flags)
799
self.transport.put_bytes('branch-format', self._format.as_string())
801
self.control_files.unlock()
1137
804
class BzrDirMeta1(BzrDir):
1143
810
present within a BzrDir.
813
def _get_branch_path(self, name):
814
"""Obtain the branch path to use.
816
This uses the API specified branch name first, and then falls back to
817
the branch name specified in the URL. If neither of those is specified,
818
it uses the default branch.
820
:param name: Optional branch name to use
821
:return: Relative path to branch
825
return urlutils.join('branches', name.encode("utf-8"))
827
def _read_branch_list(self):
828
"""Read the branch list.
830
:return: List of utf-8 encoded branch names.
833
f = self.control_transport.get('branch-list')
834
except errors.NoSuchFile:
840
ret.append(name.rstrip("\n"))
845
def _write_branch_list(self, branches):
846
"""Write out the branch list.
848
:param branches: List of utf-8 branch names to write
850
self.transport.put_bytes('branch-list',
851
"".join([name+"\n" for name in branches]))
853
def __init__(self, _transport, _format):
854
super(BzrDirMeta1, self).__init__(_transport, _format)
855
self.control_files = lockable_files.LockableFiles(
856
self.control_transport, self._format._lock_file_name,
857
self._format._lock_class)
1146
859
def can_convert_format(self):
1147
860
"""See BzrDir.can_convert_format()."""
1150
def create_branch(self, name=None, repository=None):
1151
"""See BzrDir.create_branch."""
863
def create_branch(self, name=None, repository=None,
864
append_revisions_only=None):
865
"""See ControlDir.create_branch."""
867
name = self._get_selected_branch()
1152
868
return self._format.get_branch_format().initialize(self, name=name,
1153
repository=repository)
869
repository=repository,
870
append_revisions_only=append_revisions_only)
1155
872
def destroy_branch(self, name=None):
1156
"""See BzrDir.create_branch."""
1157
if name is not None:
1158
raise errors.NoColocatedBranchSupport(self)
1159
self.transport.delete_tree('branch')
873
"""See ControlDir.destroy_branch."""
875
name = self._get_selected_branch()
876
path = self._get_branch_path(name)
878
self.control_files.lock_write()
880
branches = self._read_branch_list()
882
branches.remove(name.encode("utf-8"))
884
raise errors.NotBranchError(name)
885
self._write_branch_list(branches)
887
self.control_files.unlock()
889
self.transport.delete_tree(path)
890
except errors.NoSuchFile:
891
raise errors.NotBranchError(path=urlutils.join(self.transport.base,
1161
894
def create_repository(self, shared=False):
1162
895
"""See BzrDir.create_repository."""
1204
940
def get_branch_reference(self, name=None):
1205
941
"""See BzrDir.get_branch_reference()."""
1206
from bzrlib.branch import BranchFormat
1207
format = BranchFormat.find_format(self, name=name)
942
from bzrlib.branch import BranchFormatMetadir
943
format = BranchFormatMetadir.find_format(self, name=name)
1208
944
return format.get_reference(self, name=name)
946
def set_branch_reference(self, target_branch, name=None):
947
format = _mod_branch.BranchReferenceFormat()
948
return format.initialize(self, target_branch=target_branch, name=name)
1210
950
def get_branch_transport(self, branch_format, name=None):
1211
951
"""See BzrDir.get_branch_transport()."""
1212
if name is not None:
1213
raise errors.NoColocatedBranchSupport(self)
953
name = self._get_selected_branch()
954
path = self._get_branch_path(name)
1214
955
# XXX: this shouldn't implicitly create the directory if it's just
1215
956
# promising to get a transport -- mbp 20090727
1216
957
if branch_format is None:
1217
return self.transport.clone('branch')
958
return self.transport.clone(path)
1219
960
branch_format.get_format_string()
1220
961
except NotImplementedError:
1221
962
raise errors.IncompatibleFormat(branch_format, self._format)
964
branches = self._read_branch_list()
965
utf8_name = name.encode("utf-8")
966
if not utf8_name in branches:
967
self.control_files.lock_write()
969
branches = self._read_branch_list()
970
dirname = urlutils.dirname(utf8_name)
971
if dirname != "" and dirname in branches:
972
raise errors.ParentBranchExists(name)
974
b.startswith(utf8_name+"/") for b in branches]
975
if any(child_branches):
976
raise errors.AlreadyBranchError(name)
977
branches.append(utf8_name)
978
self._write_branch_list(branches)
980
self.control_files.unlock()
981
branch_transport = self.transport.clone(path)
982
mode = self._get_mkdir_mode()
983
branch_transport.create_prefix(mode=mode)
1223
self.transport.mkdir('branch', mode=self._get_mkdir_mode())
985
self.transport.mkdir(path, mode=mode)
1224
986
except errors.FileExists:
1226
return self.transport.clone('branch')
988
return self.transport.clone(path)
1228
990
def get_repository_transport(self, repository_format):
1229
991
"""See BzrDir.get_repository_transport()."""
1254
1016
return self.transport.clone('checkout')
1018
def get_branches(self):
1019
"""See ControlDir.get_branches."""
1022
ret[""] = self.open_branch(name="")
1023
except (errors.NotBranchError, errors.NoRepositoryPresent):
1026
for name in self._read_branch_list():
1027
ret[name] = self.open_branch(name=name.decode('utf-8'))
1256
1031
def has_workingtree(self):
1257
1032
"""Tell if this bzrdir contains a working tree.
1259
1034
Note: if you're going to open the working tree, you should just go
1260
1035
ahead and try, and not ask permission first.
1262
from bzrlib.workingtree import WorkingTreeFormat
1037
from bzrlib.workingtree import WorkingTreeFormatMetaDir
1264
WorkingTreeFormat.find_format_string(self)
1039
WorkingTreeFormatMetaDir.find_format_string(self)
1265
1040
except errors.NoWorkingTree:
1269
1044
def needs_format_conversion(self, format):
1270
1045
"""See BzrDir.needs_format_conversion()."""
1271
if not isinstance(self._format, format.__class__):
1046
if (not isinstance(self._format, format.__class__) or
1047
self._format.get_format_string() != format.get_format_string()):
1272
1048
# it is not a meta dir format, conversion is needed.
1274
1050
# we might want to push this down to the repository?
1297
1073
def open_branch(self, name=None, unsupported=False,
1298
ignore_fallbacks=False):
1299
"""See BzrDir.open_branch."""
1074
ignore_fallbacks=False, possible_transports=None):
1075
"""See ControlDir.open_branch."""
1077
name = self._get_selected_branch()
1300
1078
format = self.find_branch_format(name=name)
1301
1079
format.check_support_status(unsupported)
1302
1080
return format.open(self, name=name,
1303
_found=True, ignore_fallbacks=ignore_fallbacks)
1081
_found=True, ignore_fallbacks=ignore_fallbacks,
1082
possible_transports=possible_transports)
1305
1084
def open_repository(self, unsupported=False):
1306
1085
"""See BzrDir.open_repository."""
1307
from bzrlib.repository import RepositoryFormat
1308
format = RepositoryFormat.find_format(self)
1086
from bzrlib.repository import RepositoryFormatMetaDir
1087
format = RepositoryFormatMetaDir.find_format(self)
1309
1088
format.check_support_status(unsupported)
1310
1089
return format.open(self, _found=True)
1312
1091
def open_workingtree(self, unsupported=False,
1313
1092
recommend_upgrade=True):
1314
1093
"""See BzrDir.open_workingtree."""
1315
from bzrlib.workingtree import WorkingTreeFormat
1316
format = WorkingTreeFormat.find_format(self)
1094
from bzrlib.workingtree import WorkingTreeFormatMetaDir
1095
format = WorkingTreeFormatMetaDir.find_format(self)
1317
1096
format.check_support_status(unsupported, recommend_upgrade,
1318
1097
basedir=self.root_transport.base)
1319
1098
return format.open(self, _found=True)
1322
1101
return config.TransportConfig(self.transport, 'control.conf')
1104
class BzrFormat(object):
1105
"""Base class for all formats of things living in metadirs.
1107
This class manages the format string that is stored in the 'format'
1108
or 'branch-format' file.
1110
All classes for (branch-, repository-, workingtree-) formats that
1111
live in meta directories and have their own 'format' file
1112
(i.e. different from .bzr/branch-format) derive from this class,
1113
as well as the relevant base class for their kind
1114
(BranchFormat, WorkingTreeFormat, RepositoryFormat).
1116
Each format is identified by a "format" or "branch-format" file with a
1117
single line containing the base format name and then an optional list of
1120
Feature flags are supported as of bzr 2.5. Setting feature flags on formats
1121
will render them inaccessible to older versions of bzr.
1123
:ivar features: Dictionary mapping feature names to their necessity
1126
_present_features = set()
1132
def register_feature(cls, name):
1133
"""Register a feature as being present.
1135
:param name: Name of the feature
1138
raise ValueError("spaces are not allowed in feature names")
1139
if name in cls._present_features:
1140
raise errors.FeatureAlreadyRegistered(name)
1141
cls._present_features.add(name)
1144
def unregister_feature(cls, name):
1145
"""Unregister a feature."""
1146
cls._present_features.remove(name)
1148
def check_support_status(self, allow_unsupported, recommend_upgrade=True,
1150
for name, necessity in self.features.iteritems():
1151
if name in self._present_features:
1153
if necessity == "optional":
1154
mutter("ignoring optional missing feature %s", name)
1156
elif necessity == "required":
1157
raise errors.MissingFeature(name)
1159
mutter("treating unknown necessity as require for %s",
1161
raise errors.MissingFeature(name)
1164
def get_format_string(cls):
1165
"""Return the ASCII format string that identifies this format."""
1166
raise NotImplementedError(cls.get_format_string)
1169
def from_string(cls, text):
1170
format_string = cls.get_format_string()
1171
if not text.startswith(format_string):
1172
raise AssertionError("Invalid format header %r for %r" % (text, cls))
1173
lines = text[len(format_string):].splitlines()
1175
for lineno, line in enumerate(lines):
1177
(necessity, feature) = line.split(" ", 1)
1179
raise errors.ParseFormatError(format=cls, lineno=lineno+2,
1180
line=line, text=text)
1181
ret.features[feature] = necessity
1184
def as_string(self):
1185
"""Return the string representation of this format.
1187
lines = [self.get_format_string()]
1188
lines.extend([("%s %s\n" % (item[1], item[0])) for item in
1189
self.features.iteritems()])
1190
return "".join(lines)
1193
def _find_format(klass, registry, kind, format_string):
1195
first_line = format_string[:format_string.index("\n")+1]
1197
first_line = format_string
1199
cls = registry.get(first_line)
1201
raise errors.UnknownFormatError(format=first_line, kind=kind)
1202
return cls.from_string(format_string)
1204
def network_name(self):
1205
"""A simple byte string uniquely identifying this format for RPC calls.
1207
Metadir branch formats use their format string.
1209
return self.as_string()
1211
def __eq__(self, other):
1212
return (self.__class__ is other.__class__ and
1213
self.features == other.features)
1215
def _update_feature_flags(self, updated_flags):
1216
"""Update the feature flags in this format.
1218
:param updated_flags: Updated feature flags
1220
for name, necessity in updated_flags.iteritems():
1221
if necessity is None:
1223
del self.features[name]
1227
self.features[name] = necessity
1325
1230
class BzrProber(controldir.Prober):
1326
1231
"""Prober for formats that use a .bzr/ control directory."""
1830
1763
controldir.ControlDirFormat._default_format = BzrDirMetaFormat1()
1766
class BzrDirMetaFormat1Colo(BzrDirMetaFormat1):
1767
"""BzrDirMeta1 format with support for colocated branches."""
1769
colocated_branches = True
1772
def get_format_string(cls):
1773
"""See BzrDirFormat.get_format_string()."""
1774
return "Bazaar meta directory, format 1 (with colocated branches)\n"
1776
def get_format_description(self):
1777
"""See BzrDirFormat.get_format_description()."""
1778
return "Meta directory format 1 with support for colocated branches"
1780
def _open(self, transport):
1781
"""See BzrDirFormat._open."""
1782
# Create a new format instance because otherwise initialisation of new
1783
# metadirs share the global default format object leading to alias
1785
format = BzrDirMetaFormat1Colo()
1786
self._supply_sub_formats_to(format)
1787
return BzrDirMeta1(transport, format)
1790
BzrProber.formats.register(BzrDirMetaFormat1Colo.get_format_string(),
1791
BzrDirMetaFormat1Colo)
1833
1794
class ConvertMetaToMeta(controldir.Converter):
1834
1795
"""Converts the components of metadirs."""
1908
1869
return to_convert
1872
class ConvertMetaToColo(controldir.Converter):
1873
"""Add colocated branch support."""
1875
def __init__(self, target_format):
1876
"""Create a converter.that upgrades a metadir to the colo format.
1878
:param target_format: The final metadir format that is desired.
1880
self.target_format = target_format
1882
def convert(self, to_convert, pb):
1883
"""See Converter.convert()."""
1884
to_convert.transport.put_bytes('branch-format',
1885
self.target_format.as_string())
1886
return BzrDir.open_from_transport(to_convert.root_transport)
1889
class ConvertMetaToColo(controldir.Converter):
1890
"""Convert a 'development-colo' bzrdir to a '2a' bzrdir."""
1892
def __init__(self, target_format):
1893
"""Create a converter that converts a 'development-colo' metadir
1896
:param target_format: The final metadir format that is desired.
1898
self.target_format = target_format
1900
def convert(self, to_convert, pb):
1901
"""See Converter.convert()."""
1902
to_convert.transport.put_bytes('branch-format',
1903
self.target_format.as_string())
1904
return BzrDir.open_from_transport(to_convert.root_transport)
1911
1907
controldir.ControlDirFormat.register_server_prober(RemoteBzrProber)
2021
2018
require_stacking)
2022
2019
self._bzrdir = bzrdir
2024
def acquire_repository(self, make_working_trees=None, shared=False):
2021
def acquire_repository(self, make_working_trees=None, shared=False,
2022
possible_transports=None):
2025
2023
"""Implementation of RepositoryAcquisitionPolicy.acquire_repository
2027
2025
Creates the desired repository in the bzrdir we already have.
2027
if possible_transports is None:
2028
possible_transports = []
2030
possible_transports = list(possible_transports)
2031
possible_transports.append(self._bzrdir.root_transport)
2029
2032
stack_on = self._get_full_stack_on()
2031
2034
format = self._bzrdir._format
2032
2035
format.require_stacking(stack_on=stack_on,
2033
possible_transports=[self._bzrdir.root_transport])
2036
possible_transports=possible_transports)
2034
2037
if not self._require_stacking:
2035
2038
# We have picked up automatic stacking somewhere.
2036
note('Using default stacking branch %s at %s', self._stack_on,
2039
note(gettext('Using default stacking branch {0} at {1}').format(
2040
self._stack_on, self._stack_on_pwd))
2038
2041
repository = self._bzrdir.create_repository(shared=shared)
2039
2042
self._add_fallback(repository,
2040
possible_transports=[self._bzrdir.transport])
2043
possible_transports=possible_transports)
2041
2044
if make_working_trees is not None:
2042
2045
repository.set_make_working_trees(make_working_trees)
2043
2046
return repository, True
2122
2133
deprecated=True)
2123
2134
register_metadir(controldir.format_registry, 'dirstate',
2124
2135
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
2125
help='New in 0.15: Fast local operations. Compatible with bzr 0.8 and '
2126
'above when accessed over the network.',
2136
help='Format using dirstate for working trees. '
2137
'Compatible with bzr 0.8 and '
2138
'above when accessed over the network. Introduced in bzr 0.15.',
2127
2139
branch_format='bzrlib.branch.BzrBranchFormat5',
2128
2140
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2130
2142
deprecated=True)
2131
2143
register_metadir(controldir.format_registry, 'dirstate-tags',
2132
2144
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
2133
help='New in 0.15: Fast local operations and improved scaling for '
2134
'network operations. Additionally adds support for tags.'
2135
' Incompatible with bzr < 0.15.',
2145
help='Variant of dirstate with support for tags. '
2146
'Introduced in bzr 0.15.',
2136
2147
branch_format='bzrlib.branch.BzrBranchFormat6',
2137
2148
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2139
2150
deprecated=True)
2140
2151
register_metadir(controldir.format_registry, 'rich-root',
2141
2152
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit4',
2142
help='New in 1.0. Better handling of tree roots. Incompatible with'
2153
help='Variant of dirstate with better handling of tree roots. '
2154
'Introduced in bzr 1.0',
2144
2155
branch_format='bzrlib.branch.BzrBranchFormat6',
2145
2156
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2147
2158
deprecated=True)
2148
2159
register_metadir(controldir.format_registry, 'dirstate-with-subtree',
2149
2160
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
2150
help='New in 0.15: Fast local operations and improved scaling for '
2151
'network operations. Additionally adds support for versioning nested '
2152
'bzr branches. Incompatible with bzr < 0.15.',
2161
help='Variant of dirstate with support for nested trees. '
2162
'Introduced in 0.15.',
2153
2163
branch_format='bzrlib.branch.BzrBranchFormat6',
2154
2164
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2155
2165
experimental=True,
2158
2168
register_metadir(controldir.format_registry, 'pack-0.92',
2159
2169
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack1',
2160
help='New in 0.92: Pack-based format with data compatible with '
2161
'dirstate-tags format repositories. Interoperates with '
2162
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
2170
help='Pack-based format used in 1.x series. Introduced in 0.92. '
2171
'Interoperates with bzr repositories before 0.92 but cannot be '
2172
'read by bzr < 0.92. '
2164
2174
branch_format='bzrlib.branch.BzrBranchFormat6',
2165
2175
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2167
2178
register_metadir(controldir.format_registry, 'pack-0.92-subtree',
2168
2179
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack3',
2169
help='New in 0.92: Pack-based format with data compatible with '
2170
'dirstate-with-subtree format repositories. Interoperates with '
2180
help='Pack-based format used in 1.x series, with subtree support. '
2181
'Introduced in 0.92. Interoperates with '
2171
2182
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
2173
2184
branch_format='bzrlib.branch.BzrBranchFormat6',
2174
2185
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2176
2188
experimental=True,
2178
2190
register_metadir(controldir.format_registry, 'rich-root-pack',
2179
2191
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack4',
2180
help='New in 1.0: A variant of pack-0.92 that supports rich-root data '
2181
'(needed for bzr-svn and bzr-git).',
2192
help='A variant of pack-0.92 that supports rich-root data '
2193
'(needed for bzr-svn and bzr-git). Introduced in 1.0.',
2182
2194
branch_format='bzrlib.branch.BzrBranchFormat6',
2183
2195
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
2186
2199
register_metadir(controldir.format_registry, '1.6',
2187
2200
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack5',
2286
register_metadir(controldir.format_registry, 'development-colo',
2287
'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
2288
help='The 2a format with experimental support for colocated branches.\n',
2289
branch_format='bzrlib.branch.BzrBranchFormat7',
2290
tree_format='bzrlib.workingtree_4.WorkingTreeFormat6',
2292
bzrdir_format=BzrDirMetaFormat1Colo,
2265
2296
# And the development formats above will have aliased one of the following:
2267
2298
# Finally, the current format.
2268
2299
register_metadir(controldir.format_registry, '2a',
2269
2300
'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
2270
help='First format for bzr 2.0 series.\n'
2301
help='Format for the bzr 2.0 series.\n'
2271
2302
'Uses group-compress storage.\n'
2272
2303
'Provides rich roots which are a one-way transition.\n',
2273
2304
# 'storage in packs, 255-way hashed CHK inventory, bencode revision, group compress, '
added
removed
bzrlib/bzrdir.py
