262
208
local_repo = local_branch.repository
263
209
if preserve_stacking:
265
stacked_on = local_branch.get_stacked_on_url()
211
stack_on = local_branch.get_stacked_on_url()
266
212
except (errors.UnstackableBranchFormat,
267
213
errors.UnstackableRepositoryFormat,
268
214
errors.NotStacked):
270
# Bug: We create a metadir without knowing if it can support stacking,
271
# we should look up the policy needs first, or just use it as a hint,
218
# may need to copy content in
219
repository_policy = result.determine_repository_policy(
220
force_new_repo, stack_on, self.root_transport.base)
274
221
make_working_trees = local_repo.make_working_trees()
275
want_shared = local_repo.is_shared()
276
repo_format_name = format.repository_format.network_name()
278
make_working_trees = False
280
repo_format_name = None
282
result_repo, result, require_stacking, repository_policy = \
283
format.initialize_on_transport_ex(transport,
284
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
285
force_new_repo=force_new_repo, stacked_on=stacked_on,
286
stack_on_pwd=self.root_transport.base,
287
repo_format_name=repo_format_name,
288
make_working_trees=make_working_trees, shared_repo=want_shared)
291
# If the result repository is in the same place as the
292
# resulting bzr dir, it will have no content, further if the
293
# result is not stacked then we know all content should be
294
# copied, and finally if we are copying up to a specific
295
# revision_id then we can use the pending-ancestry-result which
296
# does not require traversing all of history to describe it.
297
if (result_repo.user_url == result.user_url
298
and not require_stacking and
299
revision_id is not None):
300
fetch_spec = graph.PendingAncestryResult(
301
[revision_id], local_repo)
302
result_repo.fetch(local_repo, fetch_spec=fetch_spec)
304
result_repo.fetch(local_repo, revision_id=revision_id)
308
if result_repo is not None:
309
raise AssertionError('result_repo not None(%r)' % result_repo)
222
result_repo = repository_policy.acquire_repository(
223
make_working_trees, local_repo.is_shared())
224
result_repo.fetch(local_repo, revision_id=revision_id)
310
227
# 1 if there is a branch present
311
228
# make sure its content is available in the target repository
313
230
if local_branch is not None:
314
result_branch = local_branch.clone(result, revision_id=revision_id,
315
repository_policy=repository_policy)
317
# Cheaper to check if the target is not local, than to try making
319
result.root_transport.local_abspath('.')
320
if result_repo is None or result_repo.make_working_trees():
231
result_branch = local_branch.clone(result, revision_id=revision_id)
232
if repository_policy is not None:
233
repository_policy.configure_branch(result_branch)
234
if result_repo is None or result_repo.make_working_trees():
321
236
self.open_workingtree().clone(result)
322
except (errors.NoWorkingTree, errors.NotLocalUrl):
237
except (errors.NoWorkingTree, errors.NotLocalUrl):
326
241
# TODO: This should be given a Transport, and should chdir up; otherwise
913
771
:param transport: Transport containing the bzrdir.
914
772
:param _unsupported: private.
916
for hook in BzrDir.hooks['pre_open']:
918
# Keep initial base since 'transport' may be modified while following
920
774
base = transport.base
921
776
def find_format(transport):
922
777
return transport, BzrDirFormat.find_format(
923
778
transport, _server_formats=_server_formats)
925
780
def redirected(transport, e, redirection_notice):
926
redirected_transport = transport._redirected_to(e.source, e.target)
927
if redirected_transport is None:
928
raise errors.NotBranchError(base)
781
qualified_source = e.get_source_url()
782
relpath = transport.relpath(qualified_source)
783
if not e.target.endswith(relpath):
784
# Not redirected to a branch-format, not a branch
785
raise errors.NotBranchError(path=e.target)
786
target = e.target[:-len(relpath)]
929
787
note('%s is%s redirected to %s',
930
transport.base, e.permanently, redirected_transport.base)
931
return redirected_transport
788
transport.base, e.permanently, target)
789
# Let's try with a new transport
790
# FIXME: If 'transport' has a qualifier, this should
791
# be applied again to the new transport *iff* the
792
# schemes used are the same. Uncomment this code
793
# once the function (and tests) exist.
795
#target = urlutils.copy_url_qualifiers(original, target)
796
return get_transport(target)
934
799
transport, format = do_catching_redirections(find_format,
1204
1056
where possible.
1205
1057
:param stacked: If true, create a stacked branch referring to the
1206
1058
location of this control directory.
1207
:param create_tree_if_local: If true, a working-tree will be created
1208
when working locally.
1210
1060
target_transport = get_transport(url, possible_transports)
1211
1061
target_transport.ensure_base()
1212
cloning_format = self.cloning_metadir(stacked)
1213
# Create/update the result branch
1062
cloning_format = self.cloning_metadir()
1214
1063
result = cloning_format.initialize_on_transport(target_transport)
1215
# if a stacked branch wasn't requested, we don't create one
1216
# even if the origin was stacked
1217
stacked_branch_url = None
1218
if source_branch is not None:
1065
source_branch = self.open_branch()
1066
source_repository = source_branch.repository
1220
1068
stacked_branch_url = self.root_transport.base
1221
source_repository = source_branch.repository
1070
# if a stacked branch wasn't requested, we don't create one
1071
# even if the origin was stacked
1072
stacked_branch_url = None
1073
except errors.NotBranchError:
1074
source_branch = None
1224
source_branch = self.open_branch()
1225
source_repository = source_branch.repository
1227
stacked_branch_url = self.root_transport.base
1228
except errors.NotBranchError:
1229
source_branch = None
1231
source_repository = self.open_repository()
1232
except errors.NoRepositoryPresent:
1233
source_repository = None
1076
source_repository = self.open_repository()
1077
except errors.NoRepositoryPresent:
1078
source_repository = None
1079
stacked_branch_url = None
1234
1080
repository_policy = result.determine_repository_policy(
1235
1081
force_new_repo, stacked_branch_url, require_stacking=stacked)
1236
result_repo, is_new_repo = repository_policy.acquire_repository()
1237
if is_new_repo and revision_id is not None and not stacked:
1238
fetch_spec = graph.PendingAncestryResult(
1239
[revision_id], source_repository)
1082
result_repo = repository_policy.acquire_repository()
1242
1083
if source_repository is not None:
1243
# Fetch while stacked to prevent unstacked fetch from
1245
if fetch_spec is None:
1246
result_repo.fetch(source_repository, revision_id=revision_id)
1248
result_repo.fetch(source_repository, fetch_spec=fetch_spec)
1084
# XXX: Isn't this redundant with the copy_content_into used below
1085
# after creating the branch? -- mbp 20080724
1086
result_repo.fetch(source_repository, revision_id=revision_id)
1250
if source_branch is None:
1088
# Create/update the result branch
1089
format_forced = False
1091
or repository_policy._require_stacking
1092
or repository_policy._stack_on)
1093
and not result._format.get_branch_format().supports_stacking()):
1094
# We need to make a stacked branch, but the default format for the
1095
# target doesn't support stacking. So force a branch that *can*
1097
from bzrlib.branch import BzrBranchFormat7
1098
format = BzrBranchFormat7()
1099
result_branch = format.initialize(result)
1100
mutter("using %r for stacking" % (format,))
1101
format_forced = True
1102
elif source_branch is None:
1251
1103
# this is for sprouting a bzrdir without a branch; is that
1252
1104
# actually useful?
1253
# Not especially, but it's part of the contract.
1254
1105
result_branch = result.create_branch()
1256
result_branch = source_branch.sprout(result,
1257
revision_id=revision_id, repository_policy=repository_policy)
1107
result_branch = source_branch.sprout(
1108
result, revision_id=revision_id)
1258
1109
mutter("created new branch %r" % (result_branch,))
1110
repository_policy.configure_branch(result_branch)
1111
if source_branch is not None and format_forced:
1112
# XXX: this duplicates Branch.sprout(); it probably belongs on an
1113
# InterBranch method? -- mbp 20080724
1114
source_branch.copy_content_into(result_branch,
1115
revision_id=revision_id)
1116
result_branch.set_parent(self.root_transport.base)
1260
1118
# Create/update the result working tree
1261
if (create_tree_if_local and
1262
isinstance(target_transport, local.LocalTransport) and
1263
(result_repo is None or result_repo.make_working_trees())):
1119
if isinstance(target_transport, LocalTransport) and (
1120
result_repo is None or result_repo.make_working_trees()):
1264
1121
wt = result.create_workingtree(accelerator_tree=accelerator_tree,
1265
1122
hardlink=hardlink)
1266
1123
wt.lock_write()
1306
def push_branch(self, source, revision_id=None, overwrite=False,
1307
remember=False, create_prefix=False):
1308
"""Push the source branch into this BzrDir."""
1310
# If we can open a branch, use its direct repository, otherwise see
1311
# if there is a repository without a branch.
1313
br_to = self.open_branch()
1314
except errors.NotBranchError:
1315
# Didn't find a branch, can we find a repository?
1316
repository_to = self.find_repository()
1318
# Found a branch, so we must have found a repository
1319
repository_to = br_to.repository
1321
push_result = PushResult()
1322
push_result.source_branch = source
1324
# We have a repository but no branch, copy the revisions, and then
1326
repository_to.fetch(source.repository, revision_id=revision_id)
1327
br_to = source.clone(self, revision_id=revision_id)
1328
if source.get_push_location() is None or remember:
1329
source.set_push_location(br_to.base)
1330
push_result.stacked_on = None
1331
push_result.branch_push_result = None
1332
push_result.old_revno = None
1333
push_result.old_revid = _mod_revision.NULL_REVISION
1334
push_result.target_branch = br_to
1335
push_result.master_branch = None
1336
push_result.workingtree_updated = False
1338
# We have successfully opened the branch, remember if necessary:
1339
if source.get_push_location() is None or remember:
1340
source.set_push_location(br_to.base)
1342
tree_to = self.open_workingtree()
1343
except errors.NotLocalUrl:
1344
push_result.branch_push_result = source.push(br_to,
1345
overwrite, stop_revision=revision_id)
1346
push_result.workingtree_updated = False
1347
except errors.NoWorkingTree:
1348
push_result.branch_push_result = source.push(br_to,
1349
overwrite, stop_revision=revision_id)
1350
push_result.workingtree_updated = None # Not applicable
1352
tree_to.lock_write()
1354
push_result.branch_push_result = source.push(
1355
tree_to.branch, overwrite, stop_revision=revision_id)
1359
push_result.workingtree_updated = True
1360
push_result.old_revno = push_result.branch_push_result.old_revno
1361
push_result.old_revid = push_result.branch_push_result.old_revid
1362
push_result.target_branch = \
1363
push_result.branch_push_result.target_branch
1367
class BzrDirHooks(hooks.Hooks):
1368
"""Hooks for BzrDir operations."""
1371
"""Create the default hooks."""
1372
hooks.Hooks.__init__(self)
1373
self.create_hook(hooks.HookPoint('pre_open',
1374
"Invoked before attempting to open a BzrDir with the transport "
1375
"that the open will use.", (1, 14), None))
1376
self.create_hook(hooks.HookPoint('post_repo_init',
1377
"Invoked after a repository has been initialized. "
1378
"post_repo_init is called with a "
1379
"bzrlib.bzrdir.RepoInitHookParams.",
1382
# install the default hooks
1383
BzrDir.hooks = BzrDirHooks()
1386
class RepoInitHookParams(object):
1387
"""Object holding parameters passed to *_repo_init hooks.
1389
There are 4 fields that hooks may wish to access:
1391
:ivar repository: Repository created
1392
:ivar format: Repository format
1393
:ivar bzrdir: The bzrdir for the repository
1394
:ivar shared: The repository is shared
1397
def __init__(self, repository, format, a_bzrdir, shared):
1398
"""Create a group of RepoInitHook parameters.
1400
:param repository: Repository created
1401
:param format: Repository format
1402
:param bzrdir: The bzrdir for the repository
1403
:param shared: The repository is shared
1405
self.repository = repository
1406
self.format = format
1407
self.bzrdir = a_bzrdir
1408
self.shared = shared
1410
def __eq__(self, other):
1411
return self.__dict__ == other.__dict__
1415
return "<%s for %s>" % (self.__class__.__name__,
1418
return "<%s for %s>" % (self.__class__.__name__,
1422
1160
class BzrDirPreSplitOut(BzrDir):
1423
1161
"""A common class for the all-in-one formats."""
1566
1285
# if the format is not the same as the system default,
1567
1286
# an upgrade is needed.
1568
1287
if format is None:
1569
symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
1570
% 'needs_format_conversion(format=None)')
1571
1288
format = BzrDirFormat.get_default_format()
1572
1289
return not isinstance(self._format, format.__class__)
1574
def open_branch(self, name=None, unsupported=False,
1575
ignore_fallbacks=False):
1291
def open_branch(self, unsupported=False):
1576
1292
"""See BzrDir.open_branch."""
1577
1293
from bzrlib.branch import BzrBranchFormat4
1578
1294
format = BzrBranchFormat4()
1579
1295
self._check_supported(format, unsupported)
1580
return format.open(self, name, _found=True)
1296
return format.open(self, _found=True)
1582
1298
def sprout(self, url, revision_id=None, force_new_repo=False,
1583
1299
possible_transports=None, accelerator_tree=None,
1584
hardlink=False, stacked=False, create_tree_if_local=True,
1585
source_branch=None):
1300
hardlink=False, stacked=False):
1586
1301
"""See BzrDir.sprout()."""
1587
if source_branch is not None:
1588
my_branch = self.open_branch()
1589
if source_branch.base != my_branch.base:
1590
raise AssertionError(
1591
"source branch %r is not within %r with branch %r" %
1592
(source_branch, self, my_branch))
1594
1303
raise errors.UnstackableBranchFormat(
1595
1304
self._format, self.root_transport.base)
1596
if not create_tree_if_local:
1597
raise errors.MustHaveWorkingTree(
1598
self._format, self.root_transport.base)
1599
1305
from bzrlib.workingtree import WorkingTreeFormat2
1600
1306
self._make_tail(url)
1601
1307
result = self._format._initialize_for_clone(url)
1997
1656
def initialize_on_transport(self, transport):
1998
1657
"""Initialize a new bzrdir in the base directory of a Transport."""
2000
# can we hand off the request to the smart server rather than using
2002
client_medium = transport.get_smart_medium()
2003
except errors.NoSmartMedium:
2004
return self._initialize_on_transport_vfs(transport)
2006
# Current RPC's only know how to create bzr metadir1 instances, so
2007
# we still delegate to vfs methods if the requested format is not a
2009
if type(self) != BzrDirMetaFormat1:
2010
return self._initialize_on_transport_vfs(transport)
2011
remote_format = RemoteBzrDirFormat()
2012
self._supply_sub_formats_to(remote_format)
2013
return remote_format.initialize_on_transport(transport)
2015
def initialize_on_transport_ex(self, transport, use_existing_dir=False,
2016
create_prefix=False, force_new_repo=False, stacked_on=None,
2017
stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
2018
shared_repo=False, vfs_only=False):
2019
"""Create this format on transport.
2021
The directory to initialize will be created.
2023
:param force_new_repo: Do not use a shared repository for the target,
2024
even if one is available.
2025
:param create_prefix: Create any missing directories leading up to
2027
:param use_existing_dir: Use an existing directory if one exists.
2028
:param stacked_on: A url to stack any created branch on, None to follow
2029
any target stacking policy.
2030
:param stack_on_pwd: If stack_on is relative, the location it is
2032
:param repo_format_name: If non-None, a repository will be
2033
made-or-found. Should none be found, or if force_new_repo is True
2034
the repo_format_name is used to select the format of repository to
2036
:param make_working_trees: Control the setting of make_working_trees
2037
for a new shared repository when one is made. None to use whatever
2038
default the format has.
2039
:param shared_repo: Control whether made repositories are shared or
2041
:param vfs_only: If True do not attempt to use a smart server
2042
:return: repo, bzrdir, require_stacking, repository_policy. repo is
2043
None if none was created or found, bzrdir is always valid.
2044
require_stacking is the result of examining the stacked_on
2045
parameter and any stacking policy found for the target.
2048
# Try to hand off to a smart server
2050
client_medium = transport.get_smart_medium()
2051
except errors.NoSmartMedium:
2054
# TODO: lookup the local format from a server hint.
2055
remote_dir_format = RemoteBzrDirFormat()
2056
remote_dir_format._network_name = self.network_name()
2057
self._supply_sub_formats_to(remote_dir_format)
2058
return remote_dir_format.initialize_on_transport_ex(transport,
2059
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
2060
force_new_repo=force_new_repo, stacked_on=stacked_on,
2061
stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
2062
make_working_trees=make_working_trees, shared_repo=shared_repo)
2063
# XXX: Refactor the create_prefix/no_create_prefix code into a
2064
# common helper function
2065
# The destination may not exist - if so make it according to policy.
2066
def make_directory(transport):
2067
transport.mkdir('.')
2069
def redirected(transport, e, redirection_notice):
2070
note(redirection_notice)
2071
return transport._redirected_to(e.source, e.target)
2073
transport = do_catching_redirections(make_directory, transport,
2075
except errors.FileExists:
2076
if not use_existing_dir:
2078
except errors.NoSuchFile:
2079
if not create_prefix:
2081
transport.create_prefix()
2083
require_stacking = (stacked_on is not None)
2084
# Now the target directory exists, but doesn't have a .bzr
2085
# directory. So we need to create it, along with any work to create
2086
# all of the dependent branches, etc.
2088
result = self.initialize_on_transport(transport)
2089
if repo_format_name:
2091
# use a custom format
2092
result._format.repository_format = \
2093
repository.network_format_registry.get(repo_format_name)
2094
except AttributeError:
2095
# The format didn't permit it to be set.
2097
# A repository is desired, either in-place or shared.
2098
repository_policy = result.determine_repository_policy(
2099
force_new_repo, stacked_on, stack_on_pwd,
2100
require_stacking=require_stacking)
2101
result_repo, is_new_repo = repository_policy.acquire_repository(
2102
make_working_trees, shared_repo)
2103
if not require_stacking and repository_policy._require_stacking:
2104
require_stacking = True
2105
result._format.require_stacking()
2106
result_repo.lock_write()
2109
repository_policy = None
2110
return result_repo, result, require_stacking, repository_policy
2112
def _initialize_on_transport_vfs(self, transport):
2113
"""Initialize a new bzrdir using VFS calls.
2115
:param transport: The transport to create the .bzr directory in.
2118
# Since we are creating a .bzr directory, inherit the
1658
# Since we don't have a .bzr directory, inherit the
2119
1659
# mode from the root directory
2120
1660
temp_control = lockable_files.LockableFiles(transport,
2121
1661
'', lockable_files.TransportLock)
2326
1836
repository_format = property(__return_repository_format)
2329
class BzrDirFormatAllInOne(BzrDirFormat):
2330
"""Common class for formats before meta-dirs."""
2332
def initialize_on_transport_ex(self, transport, use_existing_dir=False,
2333
create_prefix=False, force_new_repo=False, stacked_on=None,
2334
stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
2336
"""See BzrDirFormat.initialize_on_transport_ex."""
2337
require_stacking = (stacked_on is not None)
2338
# Format 5 cannot stack, but we've been asked to - actually init
2340
if require_stacking:
2341
format = BzrDirMetaFormat1()
2342
return format.initialize_on_transport_ex(transport,
2343
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
2344
force_new_repo=force_new_repo, stacked_on=stacked_on,
2345
stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
2346
make_working_trees=make_working_trees, shared_repo=shared_repo)
2347
return BzrDirFormat.initialize_on_transport_ex(self, transport,
2348
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
2349
force_new_repo=force_new_repo, stacked_on=stacked_on,
2350
stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
2351
make_working_trees=make_working_trees, shared_repo=shared_repo)
2354
class BzrDirFormat5(BzrDirFormatAllInOne):
1839
class BzrDirFormat5(BzrDirFormat):
2355
1840
"""Bzr control format 5.
2357
1842
This format is a combined format for working tree, branch and repository.
2359
- Format 2 working trees [always]
2360
- Format 4 branches [always]
1844
- Format 2 working trees [always]
1845
- Format 4 branches [always]
2361
1846
- Format 5 repositories [always]
2362
1847
Unhashed stores in the repository.
2511
1993
def set_branch_format(self, format):
2512
1994
self._branch_format = format
2514
def require_stacking(self, stack_on=None, possible_transports=None,
2516
"""We have a request to stack, try to ensure the formats support it.
2518
:param stack_on: If supplied, it is the URL to a branch that we want to
2519
stack on. Check to see if that format supports stacking before
2522
# Stacking is desired. requested by the target, but does the place it
2523
# points at support stacking? If it doesn't then we should
2524
# not implicitly upgrade. We check this here.
2525
new_repo_format = None
2526
new_branch_format = None
2528
# a bit of state for get_target_branch so that we don't try to open it
2529
# 2 times, for both repo *and* branch
2530
target = [None, False, None] # target_branch, checked, upgrade anyway
2531
def get_target_branch():
2533
# We've checked, don't check again
2535
if stack_on is None:
2536
# No target format, that means we want to force upgrading
2537
target[:] = [None, True, True]
2540
target_dir = BzrDir.open(stack_on,
2541
possible_transports=possible_transports)
2542
except errors.NotBranchError:
2543
# Nothing there, don't change formats
2544
target[:] = [None, True, False]
2546
except errors.JailBreak:
2547
# JailBreak, JFDI and upgrade anyway
2548
target[:] = [None, True, True]
2551
target_branch = target_dir.open_branch()
2552
except errors.NotBranchError:
2553
# No branch, don't upgrade formats
2554
target[:] = [None, True, False]
2556
target[:] = [target_branch, True, False]
2559
if (not _skip_repo and
2560
not self.repository_format.supports_external_lookups):
2561
# We need to upgrade the Repository.
2562
target_branch, _, do_upgrade = get_target_branch()
2563
if target_branch is None:
2564
# We don't have a target branch, should we upgrade anyway?
2566
# stack_on is inaccessible, JFDI.
2567
# TODO: bad monkey, hard-coded formats...
2568
if self.repository_format.rich_root_data:
2569
new_repo_format = pack_repo.RepositoryFormatKnitPack5RichRoot()
2571
new_repo_format = pack_repo.RepositoryFormatKnitPack5()
2573
# If the target already supports stacking, then we know the
2574
# project is already able to use stacking, so auto-upgrade
2576
new_repo_format = target_branch.repository._format
2577
if not new_repo_format.supports_external_lookups:
2578
# target doesn't, source doesn't, so don't auto upgrade
2580
new_repo_format = None
2581
if new_repo_format is not None:
2582
self.repository_format = new_repo_format
2583
note('Source repository format does not support stacking,'
2584
' using format:\n %s',
2585
new_repo_format.get_format_description())
2587
if not self.get_branch_format().supports_stacking():
2588
# We just checked the repo, now lets check if we need to
2589
# upgrade the branch format
2590
target_branch, _, do_upgrade = get_target_branch()
2591
if target_branch is None:
2593
# TODO: bad monkey, hard-coded formats...
2594
new_branch_format = branch.BzrBranchFormat7()
2596
new_branch_format = target_branch._format
2597
if not new_branch_format.supports_stacking():
2598
new_branch_format = None
2599
if new_branch_format is not None:
2600
# Does support stacking, use its format.
2601
self.set_branch_format(new_branch_format)
2602
note('Source branch format does not support stacking,'
2603
' using format:\n %s',
2604
new_branch_format.get_format_description())
2606
1996
def get_converter(self, format=None):
2607
1997
"""See BzrDirFormat.get_converter()."""
2608
1998
if format is None:
2620
2010
"""See BzrDirFormat.get_format_description()."""
2621
2011
return "Meta directory format 1"
2623
def network_name(self):
2624
return self.get_format_string()
2626
2013
def _open(self, transport):
2627
2014
"""See BzrDirFormat._open."""
2628
# Create a new format instance because otherwise initialisation of new
2629
# metadirs share the global default format object leading to alias
2631
format = BzrDirMetaFormat1()
2632
self._supply_sub_formats_to(format)
2633
return BzrDirMeta1(transport, format)
2015
return BzrDirMeta1(transport, self)
2635
2017
def __return_repository_format(self):
2636
2018
"""Circular import protection."""
2637
if self._repository_format:
2019
if getattr(self, '_repository_format', None):
2638
2020
return self._repository_format
2639
2021
from bzrlib.repository import RepositoryFormat
2640
2022
return RepositoryFormat.get_default_format()
2642
def _set_repository_format(self, value):
2024
def __set_repository_format(self, value):
2643
2025
"""Allow changing the repository format for metadir formats."""
2644
2026
self._repository_format = value
2646
repository_format = property(__return_repository_format,
2647
_set_repository_format)
2649
def _supply_sub_formats_to(self, other_format):
2650
"""Give other_format the same values for sub formats as this has.
2652
This method is expected to be used when parameterising a
2653
RemoteBzrDirFormat instance with the parameters from a
2654
BzrDirMetaFormat1 instance.
2656
:param other_format: other_format is a format which should be
2657
compatible with whatever sub formats are supported by self.
2660
if getattr(self, '_repository_format', None) is not None:
2661
other_format.repository_format = self.repository_format
2662
if self._branch_format is not None:
2663
other_format._branch_format = self._branch_format
2664
if self._workingtree_format is not None:
2665
other_format.workingtree_format = self.workingtree_format
2028
repository_format = property(__return_repository_format, __set_repository_format)
2667
2030
def __get_workingtree_format(self):
2668
2031
if self._workingtree_format is None:
3205
2553
# TODO: conversions of Branch and Tree should be done by
3206
2554
# InterXFormat lookups
3207
2555
if (isinstance(tree, workingtree.WorkingTree3) and
3208
not isinstance(tree, workingtree_4.DirStateWorkingTree) and
2556
not isinstance(tree, workingtree_4.WorkingTree4) and
3209
2557
isinstance(self.target_format.workingtree_format,
3210
workingtree_4.DirStateWorkingTreeFormat)):
2558
workingtree_4.WorkingTreeFormat4)):
3211
2559
workingtree_4.Converter3to4().convert(tree)
3212
if (isinstance(tree, workingtree_4.DirStateWorkingTree) and
3213
not isinstance(tree, workingtree_4.WorkingTree5) and
3214
isinstance(self.target_format.workingtree_format,
3215
workingtree_4.WorkingTreeFormat5)):
3216
workingtree_4.Converter4to5().convert(tree)
3217
if (isinstance(tree, workingtree_4.DirStateWorkingTree) and
3218
not isinstance(tree, workingtree_4.WorkingTree6) and
3219
isinstance(self.target_format.workingtree_format,
3220
workingtree_4.WorkingTreeFormat6)):
3221
workingtree_4.Converter4or5to6().convert(tree)
3223
2560
return to_convert
3226
# This is not in remote.py because it's relatively small, and needs to be
3227
# registered. Putting it in remote.py creates a circular import problem.
2563
# This is not in remote.py because it's small, and needs to be registered.
2564
# Putting it in remote.py creates a circular import problem.
3228
2565
# we can make it a lazy object if the control formats is turned into something
3229
2566
# like a registry.
3230
2567
class RemoteBzrDirFormat(BzrDirMetaFormat1):
3231
2568
"""Format representing bzrdirs accessed via a smart server"""
3234
BzrDirMetaFormat1.__init__(self)
3235
# XXX: It's a bit ugly that the network name is here, because we'd
3236
# like to believe that format objects are stateless or at least
3237
# immutable, However, we do at least avoid mutating the name after
3238
# it's returned. See <https://bugs.edge.launchpad.net/bzr/+bug/504102>
3239
self._network_name = None
3242
return "%s(_network_name=%r)" % (self.__class__.__name__,
3245
2570
def get_format_description(self):
3246
if self._network_name:
3247
real_format = network_format_registry.get(self._network_name)
3248
return 'Remote: ' + real_format.get_format_description()
3249
2571
return 'bzr remote bzrdir'
3251
def get_format_string(self):
3252
raise NotImplementedError(self.get_format_string)
3254
def network_name(self):
3255
if self._network_name:
3256
return self._network_name
3258
raise AssertionError("No network name set.")
3261
2574
def probe_transport(klass, transport):
3262
2575
"""Return a RemoteBzrDirFormat object if it looks possible."""
3291
2604
return local_dir_format.initialize_on_transport(transport)
3292
2605
client = _SmartClient(client_medium)
3293
2606
path = client.remote_path_from_transport(transport)
3295
response = client.call('BzrDirFormat.initialize', path)
3296
except errors.ErrorFromSmartServer, err:
3297
remote._translate_error(err, path=path)
2607
response = client.call('BzrDirFormat.initialize', path)
3298
2608
if response[0] != 'ok':
3299
2609
raise errors.SmartProtocolError('unexpected response code %s' % (response,))
3300
format = RemoteBzrDirFormat()
3301
self._supply_sub_formats_to(format)
3302
return remote.RemoteBzrDir(transport, format)
3304
def parse_NoneTrueFalse(self, arg):
3311
raise AssertionError("invalid arg %r" % arg)
3313
def _serialize_NoneTrueFalse(self, arg):
3320
def _serialize_NoneString(self, arg):
3323
def initialize_on_transport_ex(self, transport, use_existing_dir=False,
3324
create_prefix=False, force_new_repo=False, stacked_on=None,
3325
stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
3328
# hand off the request to the smart server
3329
client_medium = transport.get_smart_medium()
3330
except errors.NoSmartMedium:
3333
# Decline to open it if the server doesn't support our required
3334
# version (3) so that the VFS-based transport will do it.
3335
if client_medium.should_probe():
3337
server_version = client_medium.protocol_version()
3338
if server_version != '2':
3342
except errors.SmartProtocolError:
3343
# Apparently there's no usable smart server there, even though
3344
# the medium supports the smart protocol.
3349
client = _SmartClient(client_medium)
3350
path = client.remote_path_from_transport(transport)
3351
if client_medium._is_remote_before((1, 16)):
3354
# TODO: lookup the local format from a server hint.
3355
local_dir_format = BzrDirMetaFormat1()
3356
self._supply_sub_formats_to(local_dir_format)
3357
return local_dir_format.initialize_on_transport_ex(transport,
3358
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
3359
force_new_repo=force_new_repo, stacked_on=stacked_on,
3360
stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
3361
make_working_trees=make_working_trees, shared_repo=shared_repo,
3363
return self._initialize_on_transport_ex_rpc(client, path, transport,
3364
use_existing_dir, create_prefix, force_new_repo, stacked_on,
3365
stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
3367
def _initialize_on_transport_ex_rpc(self, client, path, transport,
3368
use_existing_dir, create_prefix, force_new_repo, stacked_on,
3369
stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
3371
args.append(self._serialize_NoneTrueFalse(use_existing_dir))
3372
args.append(self._serialize_NoneTrueFalse(create_prefix))
3373
args.append(self._serialize_NoneTrueFalse(force_new_repo))
3374
args.append(self._serialize_NoneString(stacked_on))
3375
# stack_on_pwd is often/usually our transport
3378
stack_on_pwd = transport.relpath(stack_on_pwd)
3379
if not stack_on_pwd:
3381
except errors.PathNotChild:
3383
args.append(self._serialize_NoneString(stack_on_pwd))
3384
args.append(self._serialize_NoneString(repo_format_name))
3385
args.append(self._serialize_NoneTrueFalse(make_working_trees))
3386
args.append(self._serialize_NoneTrueFalse(shared_repo))
3387
request_network_name = self._network_name or \
3388
BzrDirFormat.get_default_format().network_name()
3390
response = client.call('BzrDirFormat.initialize_ex_1.16',
3391
request_network_name, path, *args)
3392
except errors.UnknownSmartMethod:
3393
client._medium._remember_remote_is_before((1,16))
3394
local_dir_format = BzrDirMetaFormat1()
3395
self._supply_sub_formats_to(local_dir_format)
3396
return local_dir_format.initialize_on_transport_ex(transport,
3397
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
3398
force_new_repo=force_new_repo, stacked_on=stacked_on,
3399
stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
3400
make_working_trees=make_working_trees, shared_repo=shared_repo,
3402
except errors.ErrorFromSmartServer, err:
3403
remote._translate_error(err, path=path)
3404
repo_path = response[0]
3405
bzrdir_name = response[6]
3406
require_stacking = response[7]
3407
require_stacking = self.parse_NoneTrueFalse(require_stacking)
3408
format = RemoteBzrDirFormat()
3409
format._network_name = bzrdir_name
3410
self._supply_sub_formats_to(format)
3411
bzrdir = remote.RemoteBzrDir(transport, format, _client=client)
3413
repo_format = remote.response_tuple_to_repo_format(response[1:])
3414
if repo_path == '.':
3417
repo_bzrdir_format = RemoteBzrDirFormat()
3418
repo_bzrdir_format._network_name = response[5]
3419
repo_bzr = remote.RemoteBzrDir(transport.clone(repo_path),
3423
final_stack = response[8] or None
3424
final_stack_pwd = response[9] or None
3426
final_stack_pwd = urlutils.join(
3427
transport.base, final_stack_pwd)
3428
remote_repo = remote.RemoteRepository(repo_bzr, repo_format)
3429
if len(response) > 10:
3430
# Updated server verb that locks remotely.
3431
repo_lock_token = response[10] or None
3432
remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
3434
remote_repo.dont_leave_lock_in_place()
3436
remote_repo.lock_write()
3437
policy = UseExistingRepository(remote_repo, final_stack,
3438
final_stack_pwd, require_stacking)
3439
policy.acquire_repository()
3443
bzrdir._format.set_branch_format(self.get_branch_format())
3444
if require_stacking:
3445
# The repo has already been created, but we need to make sure that
3446
# we'll make a stackable branch.
3447
bzrdir._format.require_stacking(_skip_repo=True)
3448
return remote_repo, bzrdir, require_stacking, policy
2610
return remote.RemoteBzrDir(transport)
3450
2612
def _open(self, transport):
3451
return remote.RemoteBzrDir(transport, self)
2613
return remote.RemoteBzrDir(transport)
3453
2615
def __eq__(self, other):
3454
2616
if not isinstance(other, RemoteBzrDirFormat):
3456
2618
return self.get_format_description() == other.get_format_description()
3458
def __return_repository_format(self):
3459
# Always return a RemoteRepositoryFormat object, but if a specific bzr
3460
# repository format has been asked for, tell the RemoteRepositoryFormat
3461
# that it should use that for init() etc.
3462
result = remote.RemoteRepositoryFormat()
3463
custom_format = getattr(self, '_repository_format', None)
3465
if isinstance(custom_format, remote.RemoteRepositoryFormat):
3466
return custom_format
3468
# We will use the custom format to create repositories over the
3469
# wire; expose its details like rich_root_data for code to
3471
result._custom_format = custom_format
3474
def get_branch_format(self):
3475
result = BzrDirMetaFormat1.get_branch_format(self)
3476
if not isinstance(result, remote.RemoteBranchFormat):
3477
new_result = remote.RemoteBranchFormat()
3478
new_result._custom_format = result
3480
self.set_branch_format(new_result)
3484
repository_format = property(__return_repository_format,
3485
BzrDirMetaFormat1._set_repository_format) #.im_func)
3488
2621
BzrDirFormat.register_control_server_format(RemoteBzrDirFormat)
3821
2939
def acquire_repository(self, make_working_trees=None, shared=False):
3822
2940
"""Implementation of RepositoryAcquisitionPolicy.acquire_repository
3824
Returns an existing repository to use.
2942
Returns an existing repository to use
3826
self._add_fallback(self._repository,
3827
possible_transports=[self._repository.bzrdir.transport])
3828
return self._repository, False
3831
# Please register new formats after old formats so that formats
3832
# appear in chronological order and format descriptions can build
2944
self._add_fallback(self._repository)
2945
return self._repository
3834
2948
format_registry = BzrDirFormatRegistry()
3835
# The pre-0.8 formats have their repository format network name registered in
3836
# repository.py. MetaDir formats have their repository format network name
3837
# inferred from their disk format string.
3838
2949
format_registry.register('weave', BzrDirFormat6,
3839
2950
'Pre-0.8 format. Slower than knit and does not'
3840
2951
' support checkouts or shared repositories.',
3842
2952
deprecated=True)
2953
format_registry.register_metadir('knit',
2954
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
2955
'Format using knits. Recommended for interoperation with bzr <= 0.14.',
2956
branch_format='bzrlib.branch.BzrBranchFormat5',
2957
tree_format='bzrlib.workingtree.WorkingTreeFormat3')
3843
2958
format_registry.register_metadir('metaweave',
3844
2959
'bzrlib.repofmt.weaverepo.RepositoryFormat7',
3845
2960
'Transitional format in 0.8. Slower than knit.',
3846
2961
branch_format='bzrlib.branch.BzrBranchFormat5',
3847
2962
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3850
format_registry.register_metadir('knit',
3851
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3852
'Format using knits. Recommended for interoperation with bzr <= 0.14.',
3853
branch_format='bzrlib.branch.BzrBranchFormat5',
3854
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3856
2963
deprecated=True)
3857
2964
format_registry.register_metadir('dirstate',
3858
2965
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3914
3022
format_registry.register_metadir('rich-root-pack',
3915
3023
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack4',
3916
help='New in 1.0: A variant of pack-0.92 that supports rich-root data '
3917
'(needed for bzr-svn and bzr-git).',
3024
help='New in 1.0: Pack-based format with data compatible with '
3025
'rich-root format repositories. Incompatible with'
3918
3027
branch_format='bzrlib.branch.BzrBranchFormat6',
3919
3028
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3922
3030
format_registry.register_metadir('1.6',
3923
3031
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5',
3924
help='A format that allows a branch to indicate that there is another '
3925
'(stacked) repository that should be used to access data that is '
3926
'not present locally.',
3032
help='A branch and pack based repository that supports stacking. ',
3927
3033
branch_format='bzrlib.branch.BzrBranchFormat7',
3928
3034
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3931
format_registry.register_metadir('1.6.1-rich-root',
3036
format_registry.register_metadir('1.6-rich-root',
3932
3037
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5RichRoot',
3933
help='A variant of 1.6 that supports rich-root data '
3934
'(needed for bzr-svn and bzr-git).',
3935
branch_format='bzrlib.branch.BzrBranchFormat7',
3936
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3939
format_registry.register_metadir('1.9',
3940
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3941
help='A repository format using B+tree indexes. These indexes '
3942
'are smaller in size, have smarter caching and provide faster '
3943
'performance for most operations.',
3944
branch_format='bzrlib.branch.BzrBranchFormat7',
3945
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3948
format_registry.register_metadir('1.9-rich-root',
3949
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3950
help='A variant of 1.9 that supports rich-root data '
3951
'(needed for bzr-svn and bzr-git).',
3952
branch_format='bzrlib.branch.BzrBranchFormat7',
3953
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3956
format_registry.register_metadir('1.14',
3957
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3958
help='A working-tree format that supports content filtering.',
3959
branch_format='bzrlib.branch.BzrBranchFormat7',
3960
tree_format='bzrlib.workingtree.WorkingTreeFormat5',
3962
format_registry.register_metadir('1.14-rich-root',
3963
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3964
help='A variant of 1.14 that supports rich-root data '
3965
'(needed for bzr-svn and bzr-git).',
3966
branch_format='bzrlib.branch.BzrBranchFormat7',
3967
tree_format='bzrlib.workingtree.WorkingTreeFormat5',
3969
# The following un-numbered 'development' formats should always just be aliases.
3970
format_registry.register_metadir('development-rich-root',
3971
'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK1',
3972
help='Current development format. Supports rich roots. Can convert data '
3973
'to and from rich-root-pack (and anything compatible with '
3974
'rich-root-pack) format repositories. Repositories and branches in '
3975
'this format can only be read by bzr.dev. Please read '
3976
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3038
help='A branch and pack based repository that supports stacking '
3039
'and rich root data (needed for bzr-svn). ',
3040
branch_format='bzrlib.branch.BzrBranchFormat7',
3041
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3043
# The following two formats should always just be aliases.
3044
format_registry.register_metadir('development',
3045
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment1',
3046
help='Current development format. Can convert data to and from pack-0.92 '
3047
'(and anything compatible with pack-0.92) format repositories. '
3048
'Repositories and branches in this format can only be read by bzr.dev. '
3050
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3978
3052
branch_format='bzrlib.branch.BzrBranchFormat7',
3979
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3053
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3980
3054
experimental=True,
3984
3057
format_registry.register_metadir('development-subtree',
3985
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
3058
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment1Subtree',
3986
3059
help='Current development format, subtree variant. Can convert data to and '
3987
3060
'from pack-0.92-subtree (and anything compatible with '
3988
3061
'pack-0.92-subtree) format repositories. Repositories and branches in '
3989
3062
'this format can only be read by bzr.dev. Please read '
3990
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3992
branch_format='bzrlib.branch.BzrBranchFormat7',
3993
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3996
alias=False, # Restore to being an alias when an actual development subtree format is added
3997
# This current non-alias status is simply because we did not introduce a
3998
# chk based subtree format.
4001
# And the development formats above will have aliased one of the following:
4002
format_registry.register_metadir('development6-rich-root',
4003
'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK1',
4004
help='pack-1.9 with 255-way hashed CHK inv, group compress, rich roots '
4006
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
4008
branch_format='bzrlib.branch.BzrBranchFormat7',
4009
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
4014
format_registry.register_metadir('development7-rich-root',
4015
'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK2',
4016
help='pack-1.9 with 255-way hashed CHK inv, bencode revision, group compress, '
4017
'rich roots. Please read '
4018
'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
4020
branch_format='bzrlib.branch.BzrBranchFormat7',
4021
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
4026
format_registry.register_metadir('2a',
4027
'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
4028
help='First format for bzr 2.0 series.\n'
4029
'Uses group-compress storage.\n'
4030
'Provides rich roots which are a one-way transition.\n',
4031
# 'storage in packs, 255-way hashed CHK inventory, bencode revision, group compress, '
4032
# 'rich roots. Supported by bzr 1.16 and later.',
4033
branch_format='bzrlib.branch.BzrBranchFormat7',
4034
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
4038
# The following format should be an alias for the rich root equivalent
4039
# of the default format
4040
format_registry.register_metadir('default-rich-root',
4041
'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
4042
branch_format='bzrlib.branch.BzrBranchFormat7',
4043
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3063
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3065
branch_format='bzrlib.branch.BzrBranchFormat7',
3066
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3070
# And the development formats which the will have aliased one of follow:
3071
format_registry.register_metadir('development0',
3072
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment0',
3073
help='Trivial rename of pack-0.92 to provide a development format. '
3075
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3077
branch_format='bzrlib.branch.BzrBranchFormat6',
3078
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3082
format_registry.register_metadir('development0-subtree',
3083
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment0Subtree',
3084
help='Trivial rename of pack-0.92-subtree to provide a development format. '
3086
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3088
branch_format='bzrlib.branch.BzrBranchFormat6',
3089
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3093
format_registry.register_metadir('development1',
3094
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment1',
3095
help='A branch and pack based repository that supports stacking. '
3097
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3099
branch_format='bzrlib.branch.BzrBranchFormat7',
3100
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3104
format_registry.register_metadir('development1-subtree',
3105
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment1Subtree',
3106
help='A branch and pack based repository that supports stacking. '
3108
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3110
branch_format='bzrlib.branch.BzrBranchFormat7',
3111
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
4048
3115
# The current format that is made on 'bzr init'.
4049
format_registry.set_default('2a')
3116
format_registry.set_default('pack-0.92')