390
438
policy = self.determine_repository_policy(force_new_repo)
391
439
return policy.acquire_repository()[0]
393
def _find_source_repo(self, add_cleanup, source_branch):
394
"""Find the source branch and repo for a sprout operation.
396
This is helper intended for use by _sprout.
398
:returns: (source_branch, source_repository). Either or both may be
399
None. If not None, they will be read-locked (and their unlock(s)
400
scheduled via the add_cleanup param).
402
if source_branch is not None:
403
add_cleanup(source_branch.lock_read().unlock)
404
return source_branch, source_branch.repository
406
source_branch = self.open_branch()
407
source_repository = source_branch.repository
408
except errors.NotBranchError:
411
source_repository = self.open_repository()
412
except errors.NoRepositoryPresent:
413
source_repository = None
415
add_cleanup(source_repository.lock_read().unlock)
417
add_cleanup(source_branch.lock_read().unlock)
418
return source_branch, source_repository
420
def sprout(self, url, revision_id=None, force_new_repo=False,
421
recurse='down', possible_transports=None,
422
accelerator_tree=None, hardlink=False, stacked=False,
423
source_branch=None, create_tree_if_local=True):
424
"""Create a copy of this controldir prepared for use as a new line of
427
If url's last component does not exist, it will be created.
429
Attributes related to the identity of the source branch like
430
branch nickname will be cleaned, a working tree is created
431
whether one existed before or not; and a local branch is always
434
if revision_id is not None, then the clone operation may tune
435
itself to download less data.
437
:param accelerator_tree: A tree which can be used for retrieving file
438
contents more quickly than the revision tree, i.e. a workingtree.
439
The revision tree will be used for cases where accelerator_tree's
440
content is different.
441
:param hardlink: If true, hard-link files from accelerator_tree,
443
:param stacked: If true, create a stacked branch referring to the
444
location of this control directory.
445
:param create_tree_if_local: If true, a working-tree will be created
446
when working locally.
448
operation = cleanup.OperationWithCleanups(self._sprout)
449
return operation.run(url, revision_id=revision_id,
450
force_new_repo=force_new_repo, recurse=recurse,
451
possible_transports=possible_transports,
452
accelerator_tree=accelerator_tree, hardlink=hardlink,
453
stacked=stacked, source_branch=source_branch,
454
create_tree_if_local=create_tree_if_local)
456
def _sprout(self, op, url, revision_id=None, force_new_repo=False,
457
recurse='down', possible_transports=None,
458
accelerator_tree=None, hardlink=False, stacked=False,
459
source_branch=None, create_tree_if_local=True):
460
add_cleanup = op.add_cleanup
461
fetch_spec_factory = fetch.FetchSpecFactory()
462
if revision_id is not None:
463
fetch_spec_factory.add_revision_ids([revision_id])
464
fetch_spec_factory.source_branch_stop_revision_id = revision_id
465
target_transport = _mod_transport.get_transport(url,
467
target_transport.ensure_base()
468
cloning_format = self.cloning_metadir(stacked)
469
# Create/update the result branch
470
result = cloning_format.initialize_on_transport(target_transport)
471
source_branch, source_repository = self._find_source_repo(
472
add_cleanup, source_branch)
473
fetch_spec_factory.source_branch = source_branch
474
# if a stacked branch wasn't requested, we don't create one
475
# even if the origin was stacked
476
if stacked and source_branch is not None:
477
stacked_branch_url = self.root_transport.base
479
stacked_branch_url = None
480
repository_policy = result.determine_repository_policy(
481
force_new_repo, stacked_branch_url, require_stacking=stacked)
482
result_repo, is_new_repo = repository_policy.acquire_repository()
483
add_cleanup(result_repo.lock_write().unlock)
484
fetch_spec_factory.source_repo = source_repository
485
fetch_spec_factory.target_repo = result_repo
486
if stacked or (len(result_repo._fallback_repositories) != 0):
487
target_repo_kind = fetch.TargetRepoKinds.STACKED
489
target_repo_kind = fetch.TargetRepoKinds.EMPTY
491
target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
492
fetch_spec_factory.target_repo_kind = target_repo_kind
493
if source_repository is not None:
494
fetch_spec = fetch_spec_factory.make_fetch_spec()
495
result_repo.fetch(source_repository, fetch_spec=fetch_spec)
497
if source_branch is None:
498
# this is for sprouting a controldir without a branch; is that
500
# Not especially, but it's part of the contract.
501
result_branch = result.create_branch()
503
result_branch = source_branch.sprout(result,
504
revision_id=revision_id, repository_policy=repository_policy,
505
repository=result_repo)
506
mutter("created new branch %r" % (result_branch,))
508
# Create/update the result working tree
509
if (create_tree_if_local and
510
isinstance(target_transport, local.LocalTransport) and
511
(result_repo is None or result_repo.make_working_trees())):
512
wt = result.create_workingtree(accelerator_tree=accelerator_tree,
513
hardlink=hardlink, from_branch=result_branch)
516
if wt.path2id('') is None:
518
wt.set_root_id(self.open_workingtree.get_root_id())
519
except errors.NoWorkingTree:
525
if recurse == 'down':
528
basis = wt.basis_tree()
529
elif result_branch is not None:
530
basis = result_branch.basis_tree()
531
elif source_branch is not None:
532
basis = source_branch.basis_tree()
533
if basis is not None:
534
add_cleanup(basis.lock_read().unlock)
535
subtrees = basis.iter_references()
538
for path, file_id in subtrees:
539
target = urlutils.join(url, urlutils.escape(path))
540
sublocation = source_branch.reference_parent(file_id, path)
541
sublocation.bzrdir.sprout(target,
542
basis.get_reference_revision(file_id, path),
543
force_new_repo=force_new_repo, recurse=recurse,
548
442
def create_branch_convenience(base, force_new_repo=False,
549
443
force_new_tree=None, format=None,
989
class BzrDirPreSplitOut(BzrDir):
990
"""A common class for the all-in-one formats."""
992
def __init__(self, _transport, _format):
993
"""See BzrDir.__init__."""
994
super(BzrDirPreSplitOut, self).__init__(_transport, _format)
995
self._control_files = lockable_files.LockableFiles(
996
self.get_branch_transport(None),
997
self._format._lock_file_name,
998
self._format._lock_class)
1000
def break_lock(self):
1001
"""Pre-splitout bzrdirs do not suffer from stale locks."""
1002
raise NotImplementedError(self.break_lock)
1004
def cloning_metadir(self, require_stacking=False):
1005
"""Produce a metadir suitable for cloning with."""
1006
if require_stacking:
1007
return controldir.format_registry.make_bzrdir('1.6')
1008
return self._format.__class__()
1010
def clone(self, url, revision_id=None, force_new_repo=False,
1011
preserve_stacking=False):
1012
"""See BzrDir.clone().
1014
force_new_repo has no effect, since this family of formats always
1015
require a new repository.
1016
preserve_stacking has no effect, since no source branch using this
1017
family of formats can be stacked, so there is no stacking to preserve.
1019
self._make_tail(url)
1020
result = self._format._initialize_for_clone(url)
1021
self.open_repository().clone(result, revision_id=revision_id)
1022
from_branch = self.open_branch()
1023
from_branch.clone(result, revision_id=revision_id)
1025
tree = self.open_workingtree()
1026
except errors.NotLocalUrl:
1027
# make a new one, this format always has to have one.
1028
result._init_workingtree()
1033
def create_branch(self, name=None, repository=None):
1034
"""See BzrDir.create_branch."""
1035
if repository is not None:
1036
raise NotImplementedError(
1037
"create_branch(repository=<not None>) on %r" % (self,))
1038
return self._format.get_branch_format().initialize(self, name=name)
1040
def destroy_branch(self, name=None):
1041
"""See BzrDir.destroy_branch."""
1042
raise errors.UnsupportedOperation(self.destroy_branch, self)
1044
def create_repository(self, shared=False):
1045
"""See BzrDir.create_repository."""
1047
raise errors.IncompatibleFormat('shared repository', self._format)
1048
return self.open_repository()
1050
def destroy_repository(self):
1051
"""See BzrDir.destroy_repository."""
1052
raise errors.UnsupportedOperation(self.destroy_repository, self)
1054
def create_workingtree(self, revision_id=None, from_branch=None,
1055
accelerator_tree=None, hardlink=False):
1056
"""See BzrDir.create_workingtree."""
1057
# The workingtree is sometimes created when the bzrdir is created,
1058
# but not when cloning.
1060
# this looks buggy but is not -really-
1061
# because this format creates the workingtree when the bzrdir is
1063
# clone and sprout will have set the revision_id
1064
# and that will have set it for us, its only
1065
# specific uses of create_workingtree in isolation
1066
# that can do wonky stuff here, and that only
1067
# happens for creating checkouts, which cannot be
1068
# done on this format anyway. So - acceptable wart.
1070
warning("can't support hardlinked working trees in %r"
1073
result = self.open_workingtree(recommend_upgrade=False)
1074
except errors.NoSuchFile:
1075
result = self._init_workingtree()
1076
if revision_id is not None:
1077
if revision_id == _mod_revision.NULL_REVISION:
1078
result.set_parent_ids([])
1080
result.set_parent_ids([revision_id])
1083
def _init_workingtree(self):
1084
from bzrlib.workingtree import WorkingTreeFormat2
1086
return WorkingTreeFormat2().initialize(self)
1087
except errors.NotLocalUrl:
1088
# Even though we can't access the working tree, we need to
1089
# create its control files.
1090
return WorkingTreeFormat2()._stub_initialize_on_transport(
1091
self.transport, self._control_files._file_mode)
1093
def destroy_workingtree(self):
1094
"""See BzrDir.destroy_workingtree."""
1095
raise errors.UnsupportedOperation(self.destroy_workingtree, self)
1097
def destroy_workingtree_metadata(self):
1098
"""See BzrDir.destroy_workingtree_metadata."""
1099
raise errors.UnsupportedOperation(self.destroy_workingtree_metadata,
1102
def get_branch_transport(self, branch_format, name=None):
1103
"""See BzrDir.get_branch_transport()."""
1104
if name is not None:
1105
raise errors.NoColocatedBranchSupport(self)
1106
if branch_format is None:
1107
return self.transport
1109
branch_format.get_format_string()
1110
except NotImplementedError:
1111
return self.transport
1112
raise errors.IncompatibleFormat(branch_format, self._format)
1114
def get_repository_transport(self, repository_format):
1115
"""See BzrDir.get_repository_transport()."""
1116
if repository_format is None:
1117
return self.transport
1119
repository_format.get_format_string()
1120
except NotImplementedError:
1121
return self.transport
1122
raise errors.IncompatibleFormat(repository_format, self._format)
1124
def get_workingtree_transport(self, workingtree_format):
1125
"""See BzrDir.get_workingtree_transport()."""
1126
if workingtree_format is None:
1127
return self.transport
1129
workingtree_format.get_format_string()
1130
except NotImplementedError:
1131
return self.transport
1132
raise errors.IncompatibleFormat(workingtree_format, self._format)
1134
def needs_format_conversion(self, format):
1135
"""See BzrDir.needs_format_conversion()."""
1136
return not isinstance(self._format, format.__class__)
1138
def open_branch(self, name=None, unsupported=False,
1139
ignore_fallbacks=False):
1140
"""See BzrDir.open_branch."""
1141
from bzrlib.branch import BzrBranchFormat4
1142
format = BzrBranchFormat4()
1143
self._check_supported(format, unsupported)
1144
return format.open(self, name, _found=True)
1146
def sprout(self, url, revision_id=None, force_new_repo=False,
1147
possible_transports=None, accelerator_tree=None,
1148
hardlink=False, stacked=False, create_tree_if_local=True,
1149
source_branch=None):
1150
"""See BzrDir.sprout()."""
1151
if source_branch is not None:
1152
my_branch = self.open_branch()
1153
if source_branch.base != my_branch.base:
1154
raise AssertionError(
1155
"source branch %r is not within %r with branch %r" %
1156
(source_branch, self, my_branch))
1158
raise errors.UnstackableBranchFormat(
1159
self._format, self.root_transport.base)
1160
if not create_tree_if_local:
1161
raise errors.MustHaveWorkingTree(
1162
self._format, self.root_transport.base)
1163
from bzrlib.workingtree import WorkingTreeFormat2
1164
self._make_tail(url)
1165
result = self._format._initialize_for_clone(url)
1167
self.open_repository().clone(result, revision_id=revision_id)
1168
except errors.NoRepositoryPresent:
1171
self.open_branch().sprout(result, revision_id=revision_id)
1172
except errors.NotBranchError:
1175
# we always want a working tree
1176
WorkingTreeFormat2().initialize(result,
1177
accelerator_tree=accelerator_tree,
1182
class BzrDir4(BzrDirPreSplitOut):
1183
"""A .bzr version 4 control object.
1185
This is a deprecated format and may be removed after sept 2006.
1188
def create_repository(self, shared=False):
1189
"""See BzrDir.create_repository."""
1190
return self._format.repository_format.initialize(self, shared)
1192
def needs_format_conversion(self, format):
1193
"""Format 4 dirs are always in need of conversion."""
1196
def open_repository(self):
1197
"""See BzrDir.open_repository."""
1198
from bzrlib.repofmt.weaverepo import RepositoryFormat4
1199
return RepositoryFormat4().open(self, _found=True)
1202
class BzrDir5(BzrDirPreSplitOut):
1203
"""A .bzr version 5 control object.
1205
This is a deprecated format and may be removed after sept 2006.
1208
def has_workingtree(self):
1209
"""See BzrDir.has_workingtree."""
1212
def open_repository(self):
1213
"""See BzrDir.open_repository."""
1214
from bzrlib.repofmt.weaverepo import RepositoryFormat5
1215
return RepositoryFormat5().open(self, _found=True)
1217
def open_workingtree(self, _unsupported=False,
1218
recommend_upgrade=True):
1219
"""See BzrDir.create_workingtree."""
1220
from bzrlib.workingtree import WorkingTreeFormat2
1221
wt_format = WorkingTreeFormat2()
1222
# we don't warn here about upgrades; that ought to be handled for the
1224
return wt_format.open(self, _found=True)
1227
class BzrDir6(BzrDirPreSplitOut):
1228
"""A .bzr version 6 control object.
1230
This is a deprecated format and may be removed after sept 2006.
1233
def has_workingtree(self):
1234
"""See BzrDir.has_workingtree."""
1237
def open_repository(self):
1238
"""See BzrDir.open_repository."""
1239
from bzrlib.repofmt.weaverepo import RepositoryFormat6
1240
return RepositoryFormat6().open(self, _found=True)
1242
def open_workingtree(self, _unsupported=False,
1243
recommend_upgrade=True):
1244
"""See BzrDir.create_workingtree."""
1245
# we don't warn here about upgrades; that ought to be handled for the
1247
from bzrlib.workingtree import WorkingTreeFormat2
1248
return WorkingTreeFormat2().open(self, _found=True)
1136
1251
class BzrDirMeta1(BzrDir):
1137
1252
"""A .bzr meta version 1 control object.
1719
def unregister_format(klass, format):
1720
BzrProber.unregister_bzrdir_format(format)
1721
controldir.ControlDirFormat.unregister_format(format)
1722
controldir.network_format_registry.remove(format.get_format_string())
1725
class BzrDirFormat4(BzrDirFormat):
1726
"""Bzr dir format 4.
1728
This format is a combined format for working tree, branch and repository.
1730
- Format 1 working trees [always]
1731
- Format 4 branches [always]
1732
- Format 4 repositories [always]
1734
This format is deprecated: it indexes texts using a text it which is
1735
removed in format 5; write support for this format has been removed.
1738
_lock_class = lockable_files.TransportLock
1740
fixed_components = True
1742
def get_format_string(self):
1743
"""See BzrDirFormat.get_format_string()."""
1744
return "Bazaar-NG branch, format 0.0.4\n"
1746
def get_format_description(self):
1747
"""See BzrDirFormat.get_format_description()."""
1748
return "All-in-one format 4"
1750
def get_converter(self, format=None):
1751
"""See BzrDirFormat.get_converter()."""
1752
# there is one and only one upgrade path here.
1753
return ConvertBzrDir4To5()
1755
def initialize_on_transport(self, transport):
1756
"""Format 4 branches cannot be created."""
1757
raise errors.UninitializableFormat(self)
1759
def is_supported(self):
1760
"""Format 4 is not supported.
1762
It is not supported because the model changed from 4 to 5 and the
1763
conversion logic is expensive - so doing it on the fly was not
1768
def network_name(self):
1769
return self.get_format_string()
1771
def _open(self, transport):
1772
"""See BzrDirFormat._open."""
1773
return BzrDir4(transport, self)
1775
def __return_repository_format(self):
1776
"""Circular import protection."""
1777
from bzrlib.repofmt.weaverepo import RepositoryFormat4
1778
return RepositoryFormat4()
1779
repository_format = property(__return_repository_format)
1782
class BzrDirFormatAllInOne(BzrDirFormat):
1783
"""Common class for formats before meta-dirs."""
1785
fixed_components = True
1787
def initialize_on_transport_ex(self, transport, use_existing_dir=False,
1788
create_prefix=False, force_new_repo=False, stacked_on=None,
1789
stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
1791
"""See BzrDirFormat.initialize_on_transport_ex."""
1792
require_stacking = (stacked_on is not None)
1793
# Format 5 cannot stack, but we've been asked to - actually init
1795
if require_stacking:
1796
format = BzrDirMetaFormat1()
1797
return format.initialize_on_transport_ex(transport,
1798
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
1799
force_new_repo=force_new_repo, stacked_on=stacked_on,
1800
stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
1801
make_working_trees=make_working_trees, shared_repo=shared_repo)
1802
return BzrDirFormat.initialize_on_transport_ex(self, transport,
1803
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
1804
force_new_repo=force_new_repo, stacked_on=stacked_on,
1805
stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
1806
make_working_trees=make_working_trees, shared_repo=shared_repo)
1809
class BzrDirFormat5(BzrDirFormatAllInOne):
1810
"""Bzr control format 5.
1812
This format is a combined format for working tree, branch and repository.
1814
- Format 2 working trees [always]
1815
- Format 4 branches [always]
1816
- Format 5 repositories [always]
1817
Unhashed stores in the repository.
1820
_lock_class = lockable_files.TransportLock
1822
def get_format_string(self):
1823
"""See BzrDirFormat.get_format_string()."""
1824
return "Bazaar-NG branch, format 5\n"
1826
def get_branch_format(self):
1827
from bzrlib import branch
1828
return branch.BzrBranchFormat4()
1830
def get_format_description(self):
1831
"""See BzrDirFormat.get_format_description()."""
1832
return "All-in-one format 5"
1834
def get_converter(self, format=None):
1835
"""See BzrDirFormat.get_converter()."""
1836
# there is one and only one upgrade path here.
1837
return ConvertBzrDir5To6()
1839
def _initialize_for_clone(self, url):
1840
return self.initialize_on_transport(
1841
_mod_transport.get_transport(url), _cloning=True)
1843
def initialize_on_transport(self, transport, _cloning=False):
1844
"""Format 5 dirs always have working tree, branch and repository.
1846
Except when they are being cloned.
1848
from bzrlib.branch import BzrBranchFormat4
1849
from bzrlib.repofmt.weaverepo import RepositoryFormat5
1850
result = (super(BzrDirFormat5, self).initialize_on_transport(transport))
1851
RepositoryFormat5().initialize(result, _internal=True)
1853
branch = BzrBranchFormat4().initialize(result)
1854
result._init_workingtree()
1857
def network_name(self):
1858
return self.get_format_string()
1860
def _open(self, transport):
1861
"""See BzrDirFormat._open."""
1862
return BzrDir5(transport, self)
1864
def __return_repository_format(self):
1865
"""Circular import protection."""
1866
from bzrlib.repofmt.weaverepo import RepositoryFormat5
1867
return RepositoryFormat5()
1868
repository_format = property(__return_repository_format)
1871
class BzrDirFormat6(BzrDirFormatAllInOne):
1872
"""Bzr control format 6.
1874
This format is a combined format for working tree, branch and repository.
1876
- Format 2 working trees [always]
1877
- Format 4 branches [always]
1878
- Format 6 repositories [always]
1881
_lock_class = lockable_files.TransportLock
1883
def get_format_string(self):
1884
"""See BzrDirFormat.get_format_string()."""
1885
return "Bazaar-NG branch, format 6\n"
1887
def get_format_description(self):
1888
"""See BzrDirFormat.get_format_description()."""
1889
return "All-in-one format 6"
1891
def get_branch_format(self):
1892
from bzrlib import branch
1893
return branch.BzrBranchFormat4()
1895
def get_converter(self, format=None):
1896
"""See BzrDirFormat.get_converter()."""
1897
# there is one and only one upgrade path here.
1898
return ConvertBzrDir6ToMeta()
1900
def _initialize_for_clone(self, url):
1901
return self.initialize_on_transport(
1902
_mod_transport.get_transport(url), _cloning=True)
1904
def initialize_on_transport(self, transport, _cloning=False):
1905
"""Format 6 dirs always have working tree, branch and repository.
1907
Except when they are being cloned.
1909
from bzrlib.branch import BzrBranchFormat4
1910
from bzrlib.repofmt.weaverepo import RepositoryFormat6
1911
result = super(BzrDirFormat6, self).initialize_on_transport(transport)
1912
RepositoryFormat6().initialize(result, _internal=True)
1914
branch = BzrBranchFormat4().initialize(result)
1915
result._init_workingtree()
1918
def network_name(self):
1919
return self.get_format_string()
1921
def _open(self, transport):
1922
"""See BzrDirFormat._open."""
1923
return BzrDir6(transport, self)
1925
def __return_repository_format(self):
1926
"""Circular import protection."""
1927
from bzrlib.repofmt.weaverepo import RepositoryFormat6
1928
return RepositoryFormat6()
1929
repository_format = property(__return_repository_format)
1615
1932
class BzrDirMetaFormat1(BzrDirFormat):
1616
1933
"""Bzr meta control format 1
1618
1935
This is the first format with split out working tree, branch and repository
1623
- Format 3 working trees [optional]
1624
- Format 5 branches [optional]
1625
- Format 7 repositories [optional]
1938
- Format 3 working trees [optional]
1939
- Format 5 branches [optional]
1940
- Format 7 repositories [optional]
1628
1943
_lock_class = lockdir.LockDir
1828
2141
# Register bzr formats
1829
BzrProber.formats.register(BzrDirMetaFormat1.get_format_string(),
1831
controldir.ControlDirFormat._default_format = BzrDirMetaFormat1()
1834
class ConvertMetaToMeta(controldir.Converter):
2142
BzrDirFormat.register_format(BzrDirFormat4())
2143
BzrDirFormat.register_format(BzrDirFormat5())
2144
BzrDirFormat.register_format(BzrDirFormat6())
2145
__default_format = BzrDirMetaFormat1()
2146
BzrDirFormat.register_format(__default_format)
2147
controldir.ControlDirFormat._default_format = __default_format
2150
class Converter(object):
2151
"""Converts a disk format object from one format to another."""
2153
def convert(self, to_convert, pb):
2154
"""Perform the conversion of to_convert, giving feedback via pb.
2156
:param to_convert: The disk object to convert.
2157
:param pb: a progress bar to use for progress information.
2160
def step(self, message):
2161
"""Update the pb by a step."""
2163
self.pb.update(message, self.count, self.total)
2166
class ConvertBzrDir4To5(Converter):
2167
"""Converts format 4 bzr dirs to format 5."""
2170
super(ConvertBzrDir4To5, self).__init__()
2171
self.converted_revs = set()
2172
self.absent_revisions = set()
2176
def convert(self, to_convert, pb):
2177
"""See Converter.convert()."""
2178
self.bzrdir = to_convert
2180
warnings.warn("pb parameter to convert() is deprecated")
2181
self.pb = ui.ui_factory.nested_progress_bar()
2183
ui.ui_factory.note('starting upgrade from format 4 to 5')
2184
if isinstance(self.bzrdir.transport, local.LocalTransport):
2185
self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
2186
self._convert_to_weaves()
2187
return BzrDir.open(self.bzrdir.user_url)
2191
def _convert_to_weaves(self):
2192
ui.ui_factory.note('note: upgrade may be faster if all store files are ungzipped first')
2195
stat = self.bzrdir.transport.stat('weaves')
2196
if not S_ISDIR(stat.st_mode):
2197
self.bzrdir.transport.delete('weaves')
2198
self.bzrdir.transport.mkdir('weaves')
2199
except errors.NoSuchFile:
2200
self.bzrdir.transport.mkdir('weaves')
2201
# deliberately not a WeaveFile as we want to build it up slowly.
2202
self.inv_weave = Weave('inventory')
2203
# holds in-memory weaves for all files
2204
self.text_weaves = {}
2205
self.bzrdir.transport.delete('branch-format')
2206
self.branch = self.bzrdir.open_branch()
2207
self._convert_working_inv()
2208
rev_history = self.branch.revision_history()
2209
# to_read is a stack holding the revisions we still need to process;
2210
# appending to it adds new highest-priority revisions
2211
self.known_revisions = set(rev_history)
2212
self.to_read = rev_history[-1:]
2214
rev_id = self.to_read.pop()
2215
if (rev_id not in self.revisions
2216
and rev_id not in self.absent_revisions):
2217
self._load_one_rev(rev_id)
2219
to_import = self._make_order()
2220
for i, rev_id in enumerate(to_import):
2221
self.pb.update('converting revision', i, len(to_import))
2222
self._convert_one_rev(rev_id)
2224
self._write_all_weaves()
2225
self._write_all_revs()
2226
ui.ui_factory.note('upgraded to weaves:')
2227
ui.ui_factory.note(' %6d revisions and inventories' % len(self.revisions))
2228
ui.ui_factory.note(' %6d revisions not present' % len(self.absent_revisions))
2229
ui.ui_factory.note(' %6d texts' % self.text_count)
2230
self._cleanup_spare_files_after_format4()
2231
self.branch._transport.put_bytes(
2233
BzrDirFormat5().get_format_string(),
2234
mode=self.bzrdir._get_file_mode())
2236
def _cleanup_spare_files_after_format4(self):
2237
# FIXME working tree upgrade foo.
2238
for n in 'merged-patches', 'pending-merged-patches':
2240
## assert os.path.getsize(p) == 0
2241
self.bzrdir.transport.delete(n)
2242
except errors.NoSuchFile:
2244
self.bzrdir.transport.delete_tree('inventory-store')
2245
self.bzrdir.transport.delete_tree('text-store')
2247
def _convert_working_inv(self):
2248
inv = xml4.serializer_v4.read_inventory(
2249
self.branch._transport.get('inventory'))
2250
new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv, working=True)
2251
self.branch._transport.put_bytes('inventory', new_inv_xml,
2252
mode=self.bzrdir._get_file_mode())
2254
def _write_all_weaves(self):
2255
controlweaves = VersionedFileStore(self.bzrdir.transport, prefixed=False,
2256
versionedfile_class=WeaveFile)
2257
weave_transport = self.bzrdir.transport.clone('weaves')
2258
weaves = VersionedFileStore(weave_transport, prefixed=False,
2259
versionedfile_class=WeaveFile)
2260
transaction = WriteTransaction()
2264
for file_id, file_weave in self.text_weaves.items():
2265
self.pb.update('writing weave', i, len(self.text_weaves))
2266
weaves._put_weave(file_id, file_weave, transaction)
2268
self.pb.update('inventory', 0, 1)
2269
controlweaves._put_weave('inventory', self.inv_weave, transaction)
2270
self.pb.update('inventory', 1, 1)
2274
def _write_all_revs(self):
2275
"""Write all revisions out in new form."""
2276
self.bzrdir.transport.delete_tree('revision-store')
2277
self.bzrdir.transport.mkdir('revision-store')
2278
revision_transport = self.bzrdir.transport.clone('revision-store')
2280
from bzrlib.xml5 import serializer_v5
2281
from bzrlib.repofmt.weaverepo import RevisionTextStore
2282
revision_store = RevisionTextStore(revision_transport,
2283
serializer_v5, False, versionedfile.PrefixMapper(),
2284
lambda:True, lambda:True)
2286
for i, rev_id in enumerate(self.converted_revs):
2287
self.pb.update('write revision', i, len(self.converted_revs))
2288
text = serializer_v5.write_revision_to_string(
2289
self.revisions[rev_id])
2291
revision_store.add_lines(key, None, osutils.split_lines(text))
2295
def _load_one_rev(self, rev_id):
2296
"""Load a revision object into memory.
2298
Any parents not either loaded or abandoned get queued to be
2300
self.pb.update('loading revision',
2301
len(self.revisions),
2302
len(self.known_revisions))
2303
if not self.branch.repository.has_revision(rev_id):
2305
ui.ui_factory.note('revision {%s} not present in branch; '
2306
'will be converted as a ghost' %
2308
self.absent_revisions.add(rev_id)
2310
rev = self.branch.repository.get_revision(rev_id)
2311
for parent_id in rev.parent_ids:
2312
self.known_revisions.add(parent_id)
2313
self.to_read.append(parent_id)
2314
self.revisions[rev_id] = rev
2316
def _load_old_inventory(self, rev_id):
2317
f = self.branch.repository.inventory_store.get(rev_id)
2319
old_inv_xml = f.read()
2322
inv = xml4.serializer_v4.read_inventory_from_string(old_inv_xml)
2323
inv.revision_id = rev_id
2324
rev = self.revisions[rev_id]
2327
def _load_updated_inventory(self, rev_id):
2328
inv_xml = self.inv_weave.get_text(rev_id)
2329
inv = xml5.serializer_v5.read_inventory_from_string(inv_xml, rev_id)
2332
def _convert_one_rev(self, rev_id):
2333
"""Convert revision and all referenced objects to new format."""
2334
rev = self.revisions[rev_id]
2335
inv = self._load_old_inventory(rev_id)
2336
present_parents = [p for p in rev.parent_ids
2337
if p not in self.absent_revisions]
2338
self._convert_revision_contents(rev, inv, present_parents)
2339
self._store_new_inv(rev, inv, present_parents)
2340
self.converted_revs.add(rev_id)
2342
def _store_new_inv(self, rev, inv, present_parents):
2343
new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
2344
new_inv_sha1 = sha_string(new_inv_xml)
2345
self.inv_weave.add_lines(rev.revision_id,
2347
new_inv_xml.splitlines(True))
2348
rev.inventory_sha1 = new_inv_sha1
2350
def _convert_revision_contents(self, rev, inv, present_parents):
2351
"""Convert all the files within a revision.
2353
Also upgrade the inventory to refer to the text revision ids."""
2354
rev_id = rev.revision_id
2355
mutter('converting texts of revision {%s}',
2357
parent_invs = map(self._load_updated_inventory, present_parents)
2358
entries = inv.iter_entries()
2360
for path, ie in entries:
2361
self._convert_file_version(rev, ie, parent_invs)
2363
def _convert_file_version(self, rev, ie, parent_invs):
2364
"""Convert one version of one file.
2366
The file needs to be added into the weave if it is a merge
2367
of >=2 parents or if it's changed from its parent.
2369
file_id = ie.file_id
2370
rev_id = rev.revision_id
2371
w = self.text_weaves.get(file_id)
2374
self.text_weaves[file_id] = w
2375
text_changed = False
2376
parent_candiate_entries = ie.parent_candidates(parent_invs)
2377
heads = graph.Graph(self).heads(parent_candiate_entries.keys())
2378
# XXX: Note that this is unordered - and this is tolerable because
2379
# the previous code was also unordered.
2380
previous_entries = dict((head, parent_candiate_entries[head]) for head
2382
self.snapshot_ie(previous_entries, ie, w, rev_id)
2384
def get_parent_map(self, revision_ids):
2385
"""See graph.StackedParentsProvider.get_parent_map"""
2386
return dict((revision_id, self.revisions[revision_id])
2387
for revision_id in revision_ids
2388
if revision_id in self.revisions)
2390
def snapshot_ie(self, previous_revisions, ie, w, rev_id):
2391
# TODO: convert this logic, which is ~= snapshot to
2392
# a call to:. This needs the path figured out. rather than a work_tree
2393
# a v4 revision_tree can be given, or something that looks enough like
2394
# one to give the file content to the entry if it needs it.
2395
# and we need something that looks like a weave store for snapshot to
2397
#ie.snapshot(rev, PATH, previous_revisions, REVISION_TREE, InMemoryWeaveStore(self.text_weaves))
2398
if len(previous_revisions) == 1:
2399
previous_ie = previous_revisions.values()[0]
2400
if ie._unchanged(previous_ie):
2401
ie.revision = previous_ie.revision
2404
f = self.branch.repository._text_store.get(ie.text_id)
2406
file_lines = f.readlines()
2409
w.add_lines(rev_id, previous_revisions, file_lines)
2410
self.text_count += 1
2412
w.add_lines(rev_id, previous_revisions, [])
2413
ie.revision = rev_id
2415
def _make_order(self):
2416
"""Return a suitable order for importing revisions.
2418
The order must be such that an revision is imported after all
2419
its (present) parents.
2421
todo = set(self.revisions.keys())
2422
done = self.absent_revisions.copy()
2425
# scan through looking for a revision whose parents
2427
for rev_id in sorted(list(todo)):
2428
rev = self.revisions[rev_id]
2429
parent_ids = set(rev.parent_ids)
2430
if parent_ids.issubset(done):
2431
# can take this one now
2432
order.append(rev_id)
2438
class ConvertBzrDir5To6(Converter):
2439
"""Converts format 5 bzr dirs to format 6."""
2441
def convert(self, to_convert, pb):
2442
"""See Converter.convert()."""
2443
self.bzrdir = to_convert
2444
pb = ui.ui_factory.nested_progress_bar()
2446
ui.ui_factory.note('starting upgrade from format 5 to 6')
2447
self._convert_to_prefixed()
2448
return BzrDir.open(self.bzrdir.user_url)
2452
def _convert_to_prefixed(self):
2453
from bzrlib.store import TransportStore
2454
self.bzrdir.transport.delete('branch-format')
2455
for store_name in ["weaves", "revision-store"]:
2456
ui.ui_factory.note("adding prefixes to %s" % store_name)
2457
store_transport = self.bzrdir.transport.clone(store_name)
2458
store = TransportStore(store_transport, prefixed=True)
2459
for urlfilename in store_transport.list_dir('.'):
2460
filename = urlutils.unescape(urlfilename)
2461
if (filename.endswith(".weave") or
2462
filename.endswith(".gz") or
2463
filename.endswith(".sig")):
2464
file_id, suffix = os.path.splitext(filename)
2468
new_name = store._mapper.map((file_id,)) + suffix
2469
# FIXME keep track of the dirs made RBC 20060121
2471
store_transport.move(filename, new_name)
2472
except errors.NoSuchFile: # catches missing dirs strangely enough
2473
store_transport.mkdir(osutils.dirname(new_name))
2474
store_transport.move(filename, new_name)
2475
self.bzrdir.transport.put_bytes(
2477
BzrDirFormat6().get_format_string(),
2478
mode=self.bzrdir._get_file_mode())
2481
class ConvertBzrDir6ToMeta(Converter):
2482
"""Converts format 6 bzr dirs to metadirs."""
2484
def convert(self, to_convert, pb):
2485
"""See Converter.convert()."""
2486
from bzrlib.repofmt.weaverepo import RepositoryFormat7
2487
from bzrlib.branch import BzrBranchFormat5
2488
self.bzrdir = to_convert
2489
self.pb = ui.ui_factory.nested_progress_bar()
2491
self.total = 20 # the steps we know about
2492
self.garbage_inventories = []
2493
self.dir_mode = self.bzrdir._get_dir_mode()
2494
self.file_mode = self.bzrdir._get_file_mode()
2496
ui.ui_factory.note('starting upgrade from format 6 to metadir')
2497
self.bzrdir.transport.put_bytes(
2499
"Converting to format 6",
2500
mode=self.file_mode)
2501
# its faster to move specific files around than to open and use the apis...
2502
# first off, nuke ancestry.weave, it was never used.
2504
self.step('Removing ancestry.weave')
2505
self.bzrdir.transport.delete('ancestry.weave')
2506
except errors.NoSuchFile:
2508
# find out whats there
2509
self.step('Finding branch files')
2510
last_revision = self.bzrdir.open_branch().last_revision()
2511
bzrcontents = self.bzrdir.transport.list_dir('.')
2512
for name in bzrcontents:
2513
if name.startswith('basis-inventory.'):
2514
self.garbage_inventories.append(name)
2515
# create new directories for repository, working tree and branch
2516
repository_names = [('inventory.weave', True),
2517
('revision-store', True),
2519
self.step('Upgrading repository ')
2520
self.bzrdir.transport.mkdir('repository', mode=self.dir_mode)
2521
self.make_lock('repository')
2522
# we hard code the formats here because we are converting into
2523
# the meta format. The meta format upgrader can take this to a
2524
# future format within each component.
2525
self.put_format('repository', RepositoryFormat7())
2526
for entry in repository_names:
2527
self.move_entry('repository', entry)
2529
self.step('Upgrading branch ')
2530
self.bzrdir.transport.mkdir('branch', mode=self.dir_mode)
2531
self.make_lock('branch')
2532
self.put_format('branch', BzrBranchFormat5())
2533
branch_files = [('revision-history', True),
2534
('branch-name', True),
2536
for entry in branch_files:
2537
self.move_entry('branch', entry)
2539
checkout_files = [('pending-merges', True),
2540
('inventory', True),
2541
('stat-cache', False)]
2542
# If a mandatory checkout file is not present, the branch does not have
2543
# a functional checkout. Do not create a checkout in the converted
2545
for name, mandatory in checkout_files:
2546
if mandatory and name not in bzrcontents:
2547
has_checkout = False
2551
if not has_checkout:
2552
ui.ui_factory.note('No working tree.')
2553
# If some checkout files are there, we may as well get rid of them.
2554
for name, mandatory in checkout_files:
2555
if name in bzrcontents:
2556
self.bzrdir.transport.delete(name)
2558
from bzrlib.workingtree import WorkingTreeFormat3
2559
self.step('Upgrading working tree')
2560
self.bzrdir.transport.mkdir('checkout', mode=self.dir_mode)
2561
self.make_lock('checkout')
2563
'checkout', WorkingTreeFormat3())
2564
self.bzrdir.transport.delete_multi(
2565
self.garbage_inventories, self.pb)
2566
for entry in checkout_files:
2567
self.move_entry('checkout', entry)
2568
if last_revision is not None:
2569
self.bzrdir.transport.put_bytes(
2570
'checkout/last-revision', last_revision)
2571
self.bzrdir.transport.put_bytes(
2573
BzrDirMetaFormat1().get_format_string(),
2574
mode=self.file_mode)
2576
return BzrDir.open(self.bzrdir.user_url)
2578
def make_lock(self, name):
2579
"""Make a lock for the new control dir name."""
2580
self.step('Make %s lock' % name)
2581
ld = lockdir.LockDir(self.bzrdir.transport,
2583
file_modebits=self.file_mode,
2584
dir_modebits=self.dir_mode)
2587
def move_entry(self, new_dir, entry):
2588
"""Move then entry name into new_dir."""
2590
mandatory = entry[1]
2591
self.step('Moving %s' % name)
2593
self.bzrdir.transport.move(name, '%s/%s' % (new_dir, name))
2594
except errors.NoSuchFile:
2598
def put_format(self, dirname, format):
2599
self.bzrdir.transport.put_bytes('%s/format' % dirname,
2600
format.get_format_string(),
2604
class ConvertMetaToMeta(Converter):
1835
2605
"""Converts the components of metadirs."""
1837
2607
def __init__(self, target_format):
1909
2680
return to_convert
2683
# This is not in remote.py because it's relatively small, and needs to be
2684
# registered. Putting it in remote.py creates a circular import problem.
2685
# we can make it a lazy object if the control formats is turned into something
2687
class RemoteBzrDirFormat(BzrDirMetaFormat1):
2688
"""Format representing bzrdirs accessed via a smart server"""
2690
supports_workingtrees = False
2693
BzrDirMetaFormat1.__init__(self)
2694
# XXX: It's a bit ugly that the network name is here, because we'd
2695
# like to believe that format objects are stateless or at least
2696
# immutable, However, we do at least avoid mutating the name after
2697
# it's returned. See <https://bugs.launchpad.net/bzr/+bug/504102>
2698
self._network_name = None
2701
return "%s(_network_name=%r)" % (self.__class__.__name__,
2704
def get_format_description(self):
2705
if self._network_name:
2706
real_format = controldir.network_format_registry.get(self._network_name)
2707
return 'Remote: ' + real_format.get_format_description()
2708
return 'bzr remote bzrdir'
2710
def get_format_string(self):
2711
raise NotImplementedError(self.get_format_string)
2713
def network_name(self):
2714
if self._network_name:
2715
return self._network_name
2717
raise AssertionError("No network name set.")
2719
def initialize_on_transport(self, transport):
2721
# hand off the request to the smart server
2722
client_medium = transport.get_smart_medium()
2723
except errors.NoSmartMedium:
2724
# TODO: lookup the local format from a server hint.
2725
local_dir_format = BzrDirMetaFormat1()
2726
return local_dir_format.initialize_on_transport(transport)
2727
client = _SmartClient(client_medium)
2728
path = client.remote_path_from_transport(transport)
2730
response = client.call('BzrDirFormat.initialize', path)
2731
except errors.ErrorFromSmartServer, err:
2732
remote._translate_error(err, path=path)
2733
if response[0] != 'ok':
2734
raise errors.SmartProtocolError('unexpected response code %s' % (response,))
2735
format = RemoteBzrDirFormat()
2736
self._supply_sub_formats_to(format)
2737
return remote.RemoteBzrDir(transport, format)
2739
def parse_NoneTrueFalse(self, arg):
2746
raise AssertionError("invalid arg %r" % arg)
2748
def _serialize_NoneTrueFalse(self, arg):
2755
def _serialize_NoneString(self, arg):
2758
def initialize_on_transport_ex(self, transport, use_existing_dir=False,
2759
create_prefix=False, force_new_repo=False, stacked_on=None,
2760
stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
2763
# hand off the request to the smart server
2764
client_medium = transport.get_smart_medium()
2765
except errors.NoSmartMedium:
2768
# Decline to open it if the server doesn't support our required
2769
# version (3) so that the VFS-based transport will do it.
2770
if client_medium.should_probe():
2772
server_version = client_medium.protocol_version()
2773
if server_version != '2':
2777
except errors.SmartProtocolError:
2778
# Apparently there's no usable smart server there, even though
2779
# the medium supports the smart protocol.
2784
client = _SmartClient(client_medium)
2785
path = client.remote_path_from_transport(transport)
2786
if client_medium._is_remote_before((1, 16)):
2789
# TODO: lookup the local format from a server hint.
2790
local_dir_format = BzrDirMetaFormat1()
2791
self._supply_sub_formats_to(local_dir_format)
2792
return local_dir_format.initialize_on_transport_ex(transport,
2793
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
2794
force_new_repo=force_new_repo, stacked_on=stacked_on,
2795
stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
2796
make_working_trees=make_working_trees, shared_repo=shared_repo,
2798
return self._initialize_on_transport_ex_rpc(client, path, transport,
2799
use_existing_dir, create_prefix, force_new_repo, stacked_on,
2800
stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
2802
def _initialize_on_transport_ex_rpc(self, client, path, transport,
2803
use_existing_dir, create_prefix, force_new_repo, stacked_on,
2804
stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
2806
args.append(self._serialize_NoneTrueFalse(use_existing_dir))
2807
args.append(self._serialize_NoneTrueFalse(create_prefix))
2808
args.append(self._serialize_NoneTrueFalse(force_new_repo))
2809
args.append(self._serialize_NoneString(stacked_on))
2810
# stack_on_pwd is often/usually our transport
2813
stack_on_pwd = transport.relpath(stack_on_pwd)
2814
if not stack_on_pwd:
2816
except errors.PathNotChild:
2818
args.append(self._serialize_NoneString(stack_on_pwd))
2819
args.append(self._serialize_NoneString(repo_format_name))
2820
args.append(self._serialize_NoneTrueFalse(make_working_trees))
2821
args.append(self._serialize_NoneTrueFalse(shared_repo))
2822
request_network_name = self._network_name or \
2823
BzrDirFormat.get_default_format().network_name()
2825
response = client.call('BzrDirFormat.initialize_ex_1.16',
2826
request_network_name, path, *args)
2827
except errors.UnknownSmartMethod:
2828
client._medium._remember_remote_is_before((1,16))
2829
local_dir_format = BzrDirMetaFormat1()
2830
self._supply_sub_formats_to(local_dir_format)
2831
return local_dir_format.initialize_on_transport_ex(transport,
2832
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
2833
force_new_repo=force_new_repo, stacked_on=stacked_on,
2834
stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
2835
make_working_trees=make_working_trees, shared_repo=shared_repo,
2837
except errors.ErrorFromSmartServer, err:
2838
remote._translate_error(err, path=path)
2839
repo_path = response[0]
2840
bzrdir_name = response[6]
2841
require_stacking = response[7]
2842
require_stacking = self.parse_NoneTrueFalse(require_stacking)
2843
format = RemoteBzrDirFormat()
2844
format._network_name = bzrdir_name
2845
self._supply_sub_formats_to(format)
2846
bzrdir = remote.RemoteBzrDir(transport, format, _client=client)
2848
repo_format = remote.response_tuple_to_repo_format(response[1:])
2849
if repo_path == '.':
2852
repo_bzrdir_format = RemoteBzrDirFormat()
2853
repo_bzrdir_format._network_name = response[5]
2854
repo_bzr = remote.RemoteBzrDir(transport.clone(repo_path),
2858
final_stack = response[8] or None
2859
final_stack_pwd = response[9] or None
2861
final_stack_pwd = urlutils.join(
2862
transport.base, final_stack_pwd)
2863
remote_repo = remote.RemoteRepository(repo_bzr, repo_format)
2864
if len(response) > 10:
2865
# Updated server verb that locks remotely.
2866
repo_lock_token = response[10] or None
2867
remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
2869
remote_repo.dont_leave_lock_in_place()
2871
remote_repo.lock_write()
2872
policy = UseExistingRepository(remote_repo, final_stack,
2873
final_stack_pwd, require_stacking)
2874
policy.acquire_repository()
2878
bzrdir._format.set_branch_format(self.get_branch_format())
2879
if require_stacking:
2880
# The repo has already been created, but we need to make sure that
2881
# we'll make a stackable branch.
2882
bzrdir._format.require_stacking(_skip_repo=True)
2883
return remote_repo, bzrdir, require_stacking, policy
2885
def _open(self, transport):
2886
return remote.RemoteBzrDir(transport, self)
2888
def __eq__(self, other):
2889
if not isinstance(other, RemoteBzrDirFormat):
2891
return self.get_format_description() == other.get_format_description()
2893
def __return_repository_format(self):
2894
# Always return a RemoteRepositoryFormat object, but if a specific bzr
2895
# repository format has been asked for, tell the RemoteRepositoryFormat
2896
# that it should use that for init() etc.
2897
result = remote.RemoteRepositoryFormat()
2898
custom_format = getattr(self, '_repository_format', None)
2900
if isinstance(custom_format, remote.RemoteRepositoryFormat):
2901
return custom_format
2903
# We will use the custom format to create repositories over the
2904
# wire; expose its details like rich_root_data for code to
2906
result._custom_format = custom_format
2909
def get_branch_format(self):
2910
result = BzrDirMetaFormat1.get_branch_format(self)
2911
if not isinstance(result, remote.RemoteBranchFormat):
2912
new_result = remote.RemoteBranchFormat()
2913
new_result._custom_format = result
2915
self.set_branch_format(new_result)
2919
repository_format = property(__return_repository_format,
2920
BzrDirMetaFormat1._set_repository_format) #.im_func)
1912
2923
controldir.ControlDirFormat.register_server_prober(RemoteBzrProber)
2152
3179
'network operations. Additionally adds support for versioning nested '
2153
3180
'bzr branches. Incompatible with bzr < 0.15.',
2154
3181
branch_format='bzrlib.branch.BzrBranchFormat6',
2155
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3182
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2156
3183
experimental=True,
2159
3186
register_metadir(controldir.format_registry, 'pack-0.92',
2160
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack1',
3187
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack1',
2161
3188
help='New in 0.92: Pack-based format with data compatible with '
2162
3189
'dirstate-tags format repositories. Interoperates with '
2163
3190
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
2165
3192
branch_format='bzrlib.branch.BzrBranchFormat6',
2166
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3193
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2168
3195
register_metadir(controldir.format_registry, 'pack-0.92-subtree',
2169
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack3',
3196
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack3',
2170
3197
help='New in 0.92: Pack-based format with data compatible with '
2171
3198
'dirstate-with-subtree format repositories. Interoperates with '
2172
3199
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
2174
3201
branch_format='bzrlib.branch.BzrBranchFormat6',
2175
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3202
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2177
3204
experimental=True,
2179
3206
register_metadir(controldir.format_registry, 'rich-root-pack',
2180
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack4',
3207
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack4',
2181
3208
help='New in 1.0: A variant of pack-0.92 that supports rich-root data '
2182
3209
'(needed for bzr-svn and bzr-git).',
2183
3210
branch_format='bzrlib.branch.BzrBranchFormat6',
2184
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3211
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2187
3214
register_metadir(controldir.format_registry, '1.6',
2188
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack5',
3215
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5',
2189
3216
help='A format that allows a branch to indicate that there is another '
2190
3217
'(stacked) repository that should be used to access data that is '
2191
3218
'not present locally.',
2192
3219
branch_format='bzrlib.branch.BzrBranchFormat7',
2193
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3220
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2196
3223
register_metadir(controldir.format_registry, '1.6.1-rich-root',
2197
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack5RichRoot',
3224
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5RichRoot',
2198
3225
help='A variant of 1.6 that supports rich-root data '
2199
3226
'(needed for bzr-svn and bzr-git).',
2200
3227
branch_format='bzrlib.branch.BzrBranchFormat7',
2201
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3228
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2204
3231
register_metadir(controldir.format_registry, '1.9',
2205
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6',
3232
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
2206
3233
help='A repository format using B+tree indexes. These indexes '
2207
3234
'are smaller in size, have smarter caching and provide faster '
2208
3235
'performance for most operations.',
2209
3236
branch_format='bzrlib.branch.BzrBranchFormat7',
2210
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3237
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2213
3240
register_metadir(controldir.format_registry, '1.9-rich-root',
2214
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6RichRoot',
3241
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
2215
3242
help='A variant of 1.9 that supports rich-root data '
2216
3243
'(needed for bzr-svn and bzr-git).',
2217
3244
branch_format='bzrlib.branch.BzrBranchFormat7',
2218
tree_format='bzrlib.workingtree_4.WorkingTreeFormat4',
3245
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2221
3248
register_metadir(controldir.format_registry, '1.14',
2222
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6',
3249
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
2223
3250
help='A working-tree format that supports content filtering.',
2224
3251
branch_format='bzrlib.branch.BzrBranchFormat7',
2225
tree_format='bzrlib.workingtree_4.WorkingTreeFormat5',
3252
tree_format='bzrlib.workingtree.WorkingTreeFormat5',
2227
3254
register_metadir(controldir.format_registry, '1.14-rich-root',
2228
'bzrlib.repofmt.knitpack_repo.RepositoryFormatKnitPack6RichRoot',
3255
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
2229
3256
help='A variant of 1.14 that supports rich-root data '
2230
3257
'(needed for bzr-svn and bzr-git).',
2231
3258
branch_format='bzrlib.branch.BzrBranchFormat7',
2232
tree_format='bzrlib.workingtree_4.WorkingTreeFormat5',
3259
tree_format='bzrlib.workingtree.WorkingTreeFormat5',
2234
3261
# The following un-numbered 'development' formats should always just be aliases.
2235
3262
register_metadir(controldir.format_registry, 'development-subtree',
added
removed
bzrlib/bzrdir.py
