128
107
thing_to_unlock.break_lock()
109
def can_convert_format(self):
110
"""Return true if this bzrdir is one whose format we can convert from."""
130
113
def check_conversion_target(self, target_format):
131
"""Check that a bzrdir as a whole can be converted to a new format."""
132
# The only current restriction is that the repository content can be
133
# fetched compatibly with the target.
134
114
target_repo_format = target_format.repository_format
136
self.open_repository()._format.check_conversion_target(
138
except errors.NoRepositoryPresent:
139
# No repo, no problem.
142
def clone_on_transport(self, transport, revision_id=None,
143
force_new_repo=False, preserve_stacking=False, stacked_on=None,
144
create_prefix=False, use_existing_dir=True, no_tree=False,
146
"""Clone this bzrdir and its contents to transport verbatim.
148
:param transport: The transport for the location to produce the clone
149
at. If the target directory does not exist, it will be created.
150
:param revision_id: The tip revision-id to use for any branch or
151
working tree. If not None, then the clone operation may tune
115
source_repo_format = self._format.repository_format
116
source_repo_format.check_conversion_target(target_repo_format)
119
def _check_supported(format, allow_unsupported,
120
recommend_upgrade=True,
122
"""Give an error or warning on old formats.
124
:param format: may be any kind of format - workingtree, branch,
127
:param allow_unsupported: If true, allow opening
128
formats that are strongly deprecated, and which may
129
have limited functionality.
131
:param recommend_upgrade: If true (default), warn
132
the user through the ui object that they may wish
133
to upgrade the object.
135
# TODO: perhaps move this into a base Format class; it's not BzrDir
136
# specific. mbp 20070323
137
if not allow_unsupported and not format.is_supported():
138
# see open_downlevel to open legacy branches.
139
raise errors.UnsupportedFormatError(format=format)
140
if recommend_upgrade \
141
and getattr(format, 'upgrade_recommended', False):
142
ui.ui_factory.recommend_upgrade(
143
format.get_format_description(),
146
def clone(self, url, revision_id=None, force_new_repo=False):
147
"""Clone this bzrdir and its contents to url verbatim.
149
If urls last component does not exist, it will be created.
151
if revision_id is not None, then the clone operation may tune
152
152
itself to download less data.
153
:param force_new_repo: Do not use a shared repository for the target,
153
:param force_new_repo: Do not use a shared repository for the target
154
154
even if one is available.
155
:param preserve_stacking: When cloning a stacked branch, stack the
156
new branch on top of the other branch's stacked-on branch.
157
:param create_prefix: Create any missing directories leading up to
159
:param use_existing_dir: Use an existing directory if one exists.
160
:param no_tree: If set to true prevents creation of a working tree.
162
# Overview: put together a broad description of what we want to end up
163
# with; then make as few api calls as possible to do it.
165
# We may want to create a repo/branch/tree, if we do so what format
166
# would we want for each:
167
require_stacking = (stacked_on is not None)
168
format = self.cloning_metadir(require_stacking)
170
# Figure out what objects we want:
157
result = self._format.initialize(url)
172
159
local_repo = self.find_repository()
173
160
except errors.NoRepositoryPresent:
174
161
local_repo = None
175
local_branches = self.get_branches()
177
local_active_branch = local_branches['']
181
# enable fallbacks when branch is not a branch reference
182
if local_active_branch.repository.has_same_location(local_repo):
183
local_repo = local_active_branch.repository
184
if preserve_stacking:
186
stacked_on = local_active_branch.get_stacked_on_url()
187
except (_mod_branch.UnstackableBranchFormat,
188
errors.UnstackableRepositoryFormat,
191
# Bug: We create a metadir without knowing if it can support stacking,
192
# we should look up the policy needs first, or just use it as a hint,
195
make_working_trees = (local_repo.make_working_trees() and
197
want_shared = local_repo.is_shared()
198
repo_format_name = format.repository_format.network_name()
200
make_working_trees = False
202
repo_format_name = None
204
result_repo, result, require_stacking, repository_policy = \
205
format.initialize_on_transport_ex(
206
transport, use_existing_dir=use_existing_dir,
207
create_prefix=create_prefix, force_new_repo=force_new_repo,
208
stacked_on=stacked_on, stack_on_pwd=self.root_transport.base,
209
repo_format_name=repo_format_name,
210
make_working_trees=make_working_trees, shared_repo=want_shared)
213
# If the result repository is in the same place as the
214
# resulting bzr dir, it will have no content, further if the
215
# result is not stacked then we know all content should be
216
# copied, and finally if we are copying up to a specific
217
# revision_id then we can use the pending-ancestry-result which
218
# does not require traversing all of history to describe it.
219
if (result_repo.user_url == result.user_url
220
and not require_stacking
221
and revision_id is not None):
222
fetch_spec = vf_search.PendingAncestryResult(
223
[revision_id], local_repo)
224
result_repo.fetch(local_repo, fetch_spec=fetch_spec)
163
# may need to copy content in
165
result_repo = local_repo.clone(
167
revision_id=revision_id)
168
result_repo.set_make_working_trees(local_repo.make_working_trees())
171
result_repo = result.find_repository()
172
# fetch content this dir needs.
226
173
result_repo.fetch(local_repo, revision_id=revision_id)
230
if result_repo is not None:
231
raise AssertionError('result_repo not None(%r)' % result_repo)
174
except errors.NoRepositoryPresent:
175
# needed to make one anyway.
176
result_repo = local_repo.clone(
178
revision_id=revision_id)
179
result_repo.set_make_working_trees(local_repo.make_working_trees())
232
180
# 1 if there is a branch present
233
181
# make sure its content is available in the target repository
235
for name, local_branch in local_branches.items():
237
result, revision_id=(None if name != '' else revision_id),
238
repository_policy=repository_policy,
239
name=name, tag_selector=tag_selector)
241
# Cheaper to check if the target is not local, than to try making
243
result.root_transport.local_abspath('.')
244
if result_repo is None or result_repo.make_working_trees():
245
self.open_workingtree().clone(result, revision_id=revision_id)
184
self.open_branch().clone(result, revision_id=revision_id)
185
except errors.NotBranchError:
188
self.open_workingtree().clone(result)
246
189
except (errors.NoWorkingTree, errors.NotLocalUrl):
250
193
# TODO: This should be given a Transport, and should chdir up; otherwise
251
194
# this will open a new connection.
252
195
def _make_tail(self, url):
253
t = _mod_transport.get_transport(url)
256
def determine_repository_policy(self, force_new_repo=False, stack_on=None,
257
stack_on_pwd=None, require_stacking=False):
258
"""Return an object representing a policy to use.
260
This controls whether a new repository is created, and the format of
261
that repository, or some existing shared repository used instead.
263
If stack_on is supplied, will not seek a containing shared repo.
265
:param force_new_repo: If True, require a new repository to be created.
266
:param stack_on: If supplied, the location to stack on. If not
267
supplied, a default_stack_on location may be used.
268
:param stack_on_pwd: If stack_on is relative, the location it is
271
def repository_policy(found_bzrdir):
274
config = found_bzrdir.get_config()
276
stack_on = config.get_default_stack_on()
277
if stack_on is not None:
278
stack_on_pwd = found_bzrdir.user_url
280
# does it have a repository ?
282
repository = found_bzrdir.open_repository()
283
except errors.NoRepositoryPresent:
286
if (found_bzrdir.user_url != self.user_url and
287
not repository.is_shared()):
288
# Don't look higher, can't use a higher shared repo.
296
return UseExistingRepository(
297
repository, stack_on, stack_on_pwd,
298
require_stacking=require_stacking), True
300
return CreateRepository(
301
self, stack_on, stack_on_pwd,
302
require_stacking=require_stacking), True
304
if not force_new_repo:
306
policy = self._find_containing(repository_policy)
307
if policy is not None:
311
return UseExistingRepository(
312
self.open_repository(), stack_on, stack_on_pwd,
313
require_stacking=require_stacking)
314
except errors.NoRepositoryPresent:
316
return CreateRepository(self, stack_on, stack_on_pwd,
317
require_stacking=require_stacking)
196
head, tail = urlutils.split(url)
197
if tail and tail != '.':
198
t = get_transport(head)
201
except errors.FileExists:
204
# TODO: Should take a Transport
206
def create(cls, base, format=None):
207
"""Create a new BzrDir at the url 'base'.
209
This will call the current default formats initialize with base
210
as the only parameter.
212
:param format: If supplied, the format of branch to create. If not
213
supplied, the default is used.
215
if cls is not BzrDir:
216
raise AssertionError("BzrDir.create always creates the default"
217
" format, not one of %r" % cls)
218
head, tail = urlutils.split(base)
219
if tail and tail != '.':
220
t = get_transport(head)
223
except errors.FileExists:
226
format = BzrDirFormat.get_default_format()
227
return format.initialize(safe_unicode(base))
229
def create_branch(self):
230
"""Create a branch in this BzrDir.
232
The bzrdirs format will control what branch format is created.
233
For more control see BranchFormatXX.create(a_bzrdir).
235
raise NotImplementedError(self.create_branch)
238
def create_branch_and_repo(base, force_new_repo=False, format=None):
239
"""Create a new BzrDir, Branch and Repository at the url 'base'.
241
This will use the current default BzrDirFormat, and use whatever
242
repository format that that uses via bzrdir.create_branch and
243
create_repository. If a shared repository is available that is used
246
The created Branch object is returned.
248
:param base: The URL to create the branch at.
249
:param force_new_repo: If True a new repository is always created.
251
bzrdir = BzrDir.create(base, format)
252
bzrdir._find_or_create_repository(force_new_repo)
253
return bzrdir.create_branch()
319
255
def _find_or_create_repository(self, force_new_repo):
320
256
"""Create a new repository if needed, returning the repository."""
321
policy = self.determine_repository_policy(force_new_repo)
322
return policy.acquire_repository()[0]
324
def _find_source_repo(self, exit_stack, source_branch):
325
"""Find the source branch and repo for a sprout operation.
327
This is helper intended for use by _sprout.
329
:returns: (source_branch, source_repository). Either or both may be
330
None. If not None, they will be read-locked (and their unlock(s)
331
scheduled via the exit_stack param).
333
if source_branch is not None:
334
exit_stack.enter_context(source_branch.lock_read())
335
return source_branch, source_branch.repository
258
return self.create_repository()
337
source_branch = self.open_branch()
338
source_repository = source_branch.repository
339
except errors.NotBranchError:
342
source_repository = self.open_repository()
343
except errors.NoRepositoryPresent:
344
source_repository = None
346
exit_stack.enter_context(source_repository.lock_read())
348
exit_stack.enter_context(source_branch.lock_read())
349
return source_branch, source_repository
351
def sprout(self, url, revision_id=None, force_new_repo=False,
352
recurse='down', possible_transports=None,
353
accelerator_tree=None, hardlink=False, stacked=False,
354
source_branch=None, create_tree_if_local=True,
356
"""Create a copy of this controldir prepared for use as a new line of
359
If url's last component does not exist, it will be created.
361
Attributes related to the identity of the source branch like
362
branch nickname will be cleaned, a working tree is created
363
whether one existed before or not; and a local branch is always
366
if revision_id is not None, then the clone operation may tune
367
itself to download less data.
369
:param accelerator_tree: A tree which can be used for retrieving file
370
contents more quickly than the revision tree, i.e. a workingtree.
371
The revision tree will be used for cases where accelerator_tree's
372
content is different.
373
:param hardlink: If true, hard-link files from accelerator_tree,
375
:param stacked: If true, create a stacked branch referring to the
376
location of this control directory.
377
:param create_tree_if_local: If true, a working-tree will be created
378
when working locally.
379
:return: The created control directory
381
with contextlib.ExitStack() as stack:
382
fetch_spec_factory = fetch.FetchSpecFactory()
383
if revision_id is not None:
384
fetch_spec_factory.add_revision_ids([revision_id])
385
fetch_spec_factory.source_branch_stop_revision_id = revision_id
386
if possible_transports is None:
387
possible_transports = []
389
possible_transports = list(possible_transports) + [
391
target_transport = _mod_transport.get_transport(url,
393
target_transport.ensure_base()
394
cloning_format = self.cloning_metadir(stacked)
395
# Create/update the result branch
397
result = controldir.ControlDir.open_from_transport(
399
except errors.NotBranchError:
400
result = cloning_format.initialize_on_transport(target_transport)
401
source_branch, source_repository = self._find_source_repo(
402
stack, source_branch)
403
fetch_spec_factory.source_branch = source_branch
404
# if a stacked branch wasn't requested, we don't create one
405
# even if the origin was stacked
406
if stacked and source_branch is not None:
407
stacked_branch_url = self.root_transport.base
409
stacked_branch_url = None
410
repository_policy = result.determine_repository_policy(
411
force_new_repo, stacked_branch_url, require_stacking=stacked)
412
result_repo, is_new_repo = repository_policy.acquire_repository(
413
possible_transports=possible_transports)
414
stack.enter_context(result_repo.lock_write())
415
fetch_spec_factory.source_repo = source_repository
416
fetch_spec_factory.target_repo = result_repo
417
if stacked or (len(result_repo._fallback_repositories) != 0):
418
target_repo_kind = fetch.TargetRepoKinds.STACKED
420
target_repo_kind = fetch.TargetRepoKinds.EMPTY
422
target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
423
fetch_spec_factory.target_repo_kind = target_repo_kind
424
if source_repository is not None:
425
fetch_spec = fetch_spec_factory.make_fetch_spec()
426
result_repo.fetch(source_repository, fetch_spec=fetch_spec)
428
if source_branch is None:
429
# this is for sprouting a controldir without a branch; is that
431
# Not especially, but it's part of the contract.
432
result_branch = result.create_branch()
433
if revision_id is not None:
434
result_branch.generate_revision_history(revision_id)
436
result_branch = source_branch.sprout(
437
result, revision_id=revision_id,
438
repository_policy=repository_policy, repository=result_repo)
439
mutter("created new branch %r" % (result_branch,))
441
# Create/update the result working tree
442
if (create_tree_if_local and not result.has_workingtree()
443
and isinstance(target_transport, local.LocalTransport)
444
and (result_repo is None or result_repo.make_working_trees())
445
and result.open_branch(
447
possible_transports=possible_transports).name == result_branch.name):
448
wt = result.create_workingtree(
449
accelerator_tree=accelerator_tree, hardlink=hardlink,
450
from_branch=result_branch)
451
with wt.lock_write():
452
if not wt.is_versioned(''):
454
wt.set_root_id(self.open_workingtree.path2id(''))
455
except errors.NoWorkingTree:
459
if recurse == 'down':
463
basis = tree.basis_tree()
464
stack.enter_context(basis.lock_read())
465
elif result_branch is not None:
466
basis = tree = result_branch.basis_tree()
467
elif source_branch is not None:
468
basis = tree = source_branch.basis_tree()
470
stack.enter_context(tree.lock_read())
471
subtrees = tree.iter_references()
474
for path in subtrees:
475
target = urlutils.join(url, urlutils.escape(path))
476
sublocation = tree.reference_parent(
477
path, branch=result_branch,
478
possible_transports=possible_transports)
479
if sublocation is None:
481
'Ignoring nested tree %s, parent location unknown.',
484
sublocation.controldir.sprout(
485
target, basis.get_reference_revision(path),
486
force_new_repo=force_new_repo, recurse=recurse,
490
def _available_backup_name(self, base):
491
"""Find a non-existing backup file name based on base.
493
See breezy.osutils.available_backup_name about race conditions.
495
return osutils.available_backup_name(base, self.root_transport.has)
497
def backup_bzrdir(self):
498
"""Backup this bzr control directory.
500
:return: Tuple with old path name and new path name
503
with ui.ui_factory.nested_progress_bar():
504
old_path = self.root_transport.abspath('.bzr')
505
backup_dir = self._available_backup_name('backup.bzr')
506
new_path = self.root_transport.abspath(backup_dir)
508
gettext('making backup of {0}\n to {1}').format(
509
urlutils.unescape_for_display(old_path, 'utf-8'),
510
urlutils.unescape_for_display(new_path, 'utf-8')))
511
self.root_transport.copy_tree('.bzr', backup_dir)
512
return (old_path, new_path)
514
def retire_bzrdir(self, limit=10000):
260
return self.find_repository()
261
except errors.NoRepositoryPresent:
262
return self.create_repository()
265
def create_branch_convenience(base, force_new_repo=False,
266
force_new_tree=None, format=None):
267
"""Create a new BzrDir, Branch and Repository at the url 'base'.
269
This is a convenience function - it will use an existing repository
270
if possible, can be told explicitly whether to create a working tree or
273
This will use the current default BzrDirFormat, and use whatever
274
repository format that that uses via bzrdir.create_branch and
275
create_repository. If a shared repository is available that is used
276
preferentially. Whatever repository is used, its tree creation policy
279
The created Branch object is returned.
280
If a working tree cannot be made due to base not being a file:// url,
281
no error is raised unless force_new_tree is True, in which case no
282
data is created on disk and NotLocalUrl is raised.
284
:param base: The URL to create the branch at.
285
:param force_new_repo: If True a new repository is always created.
286
:param force_new_tree: If True or False force creation of a tree or
287
prevent such creation respectively.
288
:param format: Override for the for the bzrdir format to create
291
# check for non local urls
292
t = get_transport(safe_unicode(base))
293
if not isinstance(t, LocalTransport):
294
raise errors.NotLocalUrl(base)
295
bzrdir = BzrDir.create(base, format)
296
repo = bzrdir._find_or_create_repository(force_new_repo)
297
result = bzrdir.create_branch()
298
if force_new_tree or (repo.make_working_trees() and
299
force_new_tree is None):
301
bzrdir.create_workingtree()
302
except errors.NotLocalUrl:
307
def create_repository(base, shared=False, format=None):
308
"""Create a new BzrDir and Repository at the url 'base'.
310
If no format is supplied, this will default to the current default
311
BzrDirFormat by default, and use whatever repository format that that
312
uses for bzrdirformat.create_repository.
314
:param shared: Create a shared repository rather than a standalone
316
The Repository object is returned.
318
This must be overridden as an instance method in child classes, where
319
it should take no parameters and construct whatever repository format
320
that child class desires.
322
bzrdir = BzrDir.create(base, format)
323
return bzrdir.create_repository(shared)
326
def create_standalone_workingtree(base, format=None):
327
"""Create a new BzrDir, WorkingTree, Branch and Repository at 'base'.
329
'base' must be a local path or a file:// url.
331
This will use the current default BzrDirFormat, and use whatever
332
repository format that that uses for bzrdirformat.create_workingtree,
333
create_branch and create_repository.
335
:return: The WorkingTree object.
337
t = get_transport(safe_unicode(base))
338
if not isinstance(t, LocalTransport):
339
raise errors.NotLocalUrl(base)
340
bzrdir = BzrDir.create_branch_and_repo(safe_unicode(base),
342
format=format).bzrdir
343
return bzrdir.create_workingtree()
345
def create_workingtree(self, revision_id=None):
346
"""Create a working tree at this BzrDir.
348
revision_id: create it as of this revision id.
350
raise NotImplementedError(self.create_workingtree)
352
def retire_bzrdir(self):
515
353
"""Permanently disable the bzrdir.
517
355
This is done by renaming it to give the user some ability to recover
520
358
This will have horrible consequences if anyone has anything locked or
522
:param limit: number of times to retry
361
for i in xrange(10000):
527
363
to_path = '.bzr.retired.%d' % i
528
364
self.root_transport.rename('.bzr', to_path)
529
note(gettext("renamed {0} to {1}").format(
530
self.root_transport.abspath('.bzr'), to_path))
365
note("renamed %s to %s"
366
% (self.root_transport.abspath('.bzr'), to_path))
532
368
except (errors.TransportError, IOError, errors.PathError):
539
def _find_containing(self, evaluate):
540
"""Find something in a containing control directory.
542
This method will scan containing control dirs, until it finds what
543
it is looking for, decides that it will never find it, or runs out
544
of containing control directories to check.
546
It is used to implement find_repository and
547
determine_repository_policy.
549
:param evaluate: A function returning (value, stop). If stop is True,
550
the value will be returned.
554
result, stop = evaluate(found_bzrdir)
557
next_transport = found_bzrdir.root_transport.clone('..')
558
if (found_bzrdir.user_url == next_transport.base):
559
# top of the file system
561
# find the next containing bzrdir
563
found_bzrdir = self.open_containing_from_transport(
565
except errors.NotBranchError:
371
def destroy_workingtree(self):
372
"""Destroy the working tree at this BzrDir.
374
Formats that do not support this may raise UnsupportedOperation.
376
raise NotImplementedError(self.destroy_workingtree)
378
def destroy_workingtree_metadata(self):
379
"""Destroy the control files for the working tree at this BzrDir.
381
The contents of working tree files are not affected.
382
Formats that do not support this may raise UnsupportedOperation.
384
raise NotImplementedError(self.destroy_workingtree_metadata)
568
386
def find_repository(self):
569
"""Find the repository that should be used.
387
"""Find the repository that should be used for a_bzrdir.
571
389
This does not require a branch as we use it to find the repo for
572
390
new branches as well as to hook existing branches up to their
575
def usable_repository(found_bzrdir):
394
return self.open_repository()
395
except errors.NoRepositoryPresent:
397
next_transport = self.root_transport.clone('..')
399
# find the next containing bzrdir
401
found_bzrdir = BzrDir.open_containing_from_transport(
403
except errors.NotBranchError:
405
raise errors.NoRepositoryPresent(self)
576
406
# does it have a repository ?
578
408
repository = found_bzrdir.open_repository()
579
409
except errors.NoRepositoryPresent:
581
if found_bzrdir.user_url == self.user_url:
582
return repository, True
583
elif repository.is_shared():
584
return repository, True
588
found_repo = self._find_containing(usable_repository)
589
if found_repo is None:
590
raise errors.NoRepositoryPresent(self)
593
def _find_creation_modes(self):
594
"""Determine the appropriate modes for files and directories.
596
They're always set to be consistent with the base directory,
597
assuming that this transport allows setting modes.
599
# TODO: Do we need or want an option (maybe a config setting) to turn
600
# this off or override it for particular locations? -- mbp 20080512
601
if self._mode_check_done:
603
self._mode_check_done = True
605
st = self.transport.stat('.')
606
except errors.TransportNotPossible:
607
self._dir_mode = None
608
self._file_mode = None
610
# Check the directory mode, but also make sure the created
611
# directories and files are read-write for this user. This is
612
# mostly a workaround for filesystems which lie about being able to
613
# write to a directory (cygwin & win32)
614
if (st.st_mode & 0o7777 == 00000):
615
# FTP allows stat but does not return dir/file modes
616
self._dir_mode = None
617
self._file_mode = None
619
self._dir_mode = (st.st_mode & 0o7777) | 0o0700
620
# Remove the sticky and execute bits for files
621
self._file_mode = self._dir_mode & ~0o7111
623
def _get_file_mode(self):
624
"""Return Unix mode for newly created files, or None.
626
if not self._mode_check_done:
627
self._find_creation_modes()
628
return self._file_mode
630
def _get_dir_mode(self):
631
"""Return Unix mode for newly created directories, or None.
633
if not self._mode_check_done:
634
self._find_creation_modes()
635
return self._dir_mode
637
def get_config(self):
638
"""Get configuration for this BzrDir."""
639
return config.BzrDirConfig(self)
641
def _get_config(self):
642
"""By default, no configuration is available."""
410
next_transport = found_bzrdir.root_transport.clone('..')
411
if (found_bzrdir.root_transport.base == next_transport.base):
412
# top of the file system
416
if ((found_bzrdir.root_transport.base ==
417
self.root_transport.base) or repository.is_shared()):
420
raise errors.NoRepositoryPresent(self)
421
raise errors.NoRepositoryPresent(self)
423
def get_branch_transport(self, branch_format):
424
"""Get the transport for use by branch format in this BzrDir.
426
Note that bzr dirs that do not support format strings will raise
427
IncompatibleFormat if the branch format they are given has
428
a format string, and vice versa.
430
If branch_format is None, the transport is returned with no
431
checking. if it is not None, then the returned transport is
432
guaranteed to point to an existing directory ready for use.
434
raise NotImplementedError(self.get_branch_transport)
436
def get_repository_transport(self, repository_format):
437
"""Get the transport for use by repository format in this BzrDir.
439
Note that bzr dirs that do not support format strings will raise
440
IncompatibleFormat if the repository format they are given has
441
a format string, and vice versa.
443
If repository_format is None, the transport is returned with no
444
checking. if it is not None, then the returned transport is
445
guaranteed to point to an existing directory ready for use.
447
raise NotImplementedError(self.get_repository_transport)
449
def get_workingtree_transport(self, tree_format):
450
"""Get the transport for use by workingtree format in this BzrDir.
452
Note that bzr dirs that do not support format strings will raise
453
IncompatibleFormat if the workingtree format they are given has a
454
format string, and vice versa.
456
If workingtree_format is None, the transport is returned with no
457
checking. if it is not None, then the returned transport is
458
guaranteed to point to an existing directory ready for use.
460
raise NotImplementedError(self.get_workingtree_transport)
645
462
def __init__(self, _transport, _format):
646
463
"""Initialize a Bzr control dir object.
648
465
Only really common logic should reside here, concrete classes should be
649
466
made with varying behaviours.
652
469
:param _transport: the transport this dir is based at.
654
471
self._format = _format
655
# these are also under the more standard names of
656
# control_transport and user_transport
657
472
self.transport = _transport.clone('.bzr')
658
473
self.root_transport = _transport
659
self._mode_check_done = False
662
def user_transport(self):
663
return self.root_transport
666
def control_transport(self):
667
return self.transport
475
def is_control_filename(self, filename):
476
"""True if filename is the name of a path which is reserved for bzrdir's.
478
:param filename: A filename within the root transport of this bzrdir.
480
This is true IF and ONLY IF the filename is part of the namespace reserved
481
for bzr control dirs. Currently this is the '.bzr' directory in the root
482
of the root_transport. it is expected that plugins will need to extend
483
this in the future - for instance to make bzr talk with svn working
486
# this might be better on the BzrDirFormat class because it refers to
487
# all the possible bzrdir disk formats.
488
# This method is tested via the workingtree is_control_filename tests-
489
# it was extracted from WorkingTree.is_control_filename. If the methods
490
# contract is extended beyond the current trivial implementation please
491
# add new tests for it to the appropriate place.
492
return filename == '.bzr' or filename.startswith('.bzr/')
494
def needs_format_conversion(self, format=None):
495
"""Return true if this bzrdir needs convert_format run on it.
497
For instance, if the repository format is out of date but the
498
branch and working tree are not, this should return True.
500
:param format: Optional parameter indicating a specific desired
501
format we plan to arrive at.
503
raise NotImplementedError(self.needs_format_conversion)
506
def open_unsupported(base):
507
"""Open a branch which is not supported."""
508
return BzrDir.open(base, _unsupported=True)
511
def open(base, _unsupported=False):
512
"""Open an existing bzrdir, rooted at 'base' (url)
514
_unsupported is a private parameter to the BzrDir class.
516
t = get_transport(base)
517
return BzrDir.open_from_transport(t, _unsupported=_unsupported)
520
def open_from_transport(transport, _unsupported=False):
521
"""Open a bzrdir within a particular directory.
523
:param transport: Transport containing the bzrdir.
524
:param _unsupported: private.
526
base = transport.base
528
def find_format(transport):
529
return transport, BzrDirFormat.find_format(transport)
531
def redirected(transport, e, redirection_notice):
532
qualified_source = e.get_source_url()
533
relpath = transport.relpath(qualified_source)
534
if not e.target.endswith(relpath):
535
# Not redirected to a branch-format, not a branch
536
raise errors.NotBranchError(path=e.target)
537
target = e.target[:-len(relpath)]
538
note('%s is%s redirected to %s',
539
transport.base, e.permanently, target)
540
# Let's try with a new transport
541
qualified_target = e.get_target_url()[:-len(relpath)]
542
# FIXME: If 'transport' has a qualifier, this should
543
# be applied again to the new transport *iff* the
544
# schemes used are the same. It's a bit tricky to
545
# verify, so I'll punt for now
547
return get_transport(target)
550
transport, format = do_catching_redirections(find_format,
553
except errors.TooManyRedirections:
554
raise errors.NotBranchError(base)
556
BzrDir._check_supported(format, _unsupported)
557
return format.open(transport, _found=True)
559
def open_branch(self, unsupported=False):
560
"""Open the branch object at this BzrDir if one is present.
562
If unsupported is True, then no longer supported branch formats can
565
TODO: static convenience version of this?
567
raise NotImplementedError(self.open_branch)
570
def open_containing(url):
571
"""Open an existing branch which contains url.
573
:param url: url to search from.
574
See open_containing_from_transport for more detail.
576
return BzrDir.open_containing_from_transport(get_transport(url))
579
def open_containing_from_transport(a_transport):
580
"""Open an existing branch which contains a_transport.base
582
This probes for a branch at a_transport, and searches upwards from there.
584
Basically we keep looking up until we find the control directory or
585
run into the root. If there isn't one, raises NotBranchError.
586
If there is one and it is either an unrecognised format or an unsupported
587
format, UnknownFormatError or UnsupportedFormatError are raised.
588
If there is one, it is returned, along with the unused portion of url.
590
:return: The BzrDir that contains the path, and a Unicode path
591
for the rest of the URL.
593
# this gets the normalised url back. I.e. '.' -> the full path.
594
url = a_transport.base
597
result = BzrDir.open_from_transport(a_transport)
598
return result, urlutils.unescape(a_transport.relpath(url))
599
except errors.NotBranchError, e:
601
new_t = a_transport.clone('..')
602
if new_t.base == a_transport.base:
603
# reached the root, whatever that may be
604
raise errors.NotBranchError(path=url)
608
def open_containing_tree_or_branch(klass, location):
609
"""Return the branch and working tree contained by a location.
611
Returns (tree, branch, relpath).
612
If there is no tree at containing the location, tree will be None.
613
If there is no branch containing the location, an exception will be
615
relpath is the portion of the path that is contained by the branch.
617
bzrdir, relpath = klass.open_containing(location)
619
tree = bzrdir.open_workingtree()
620
except (errors.NoWorkingTree, errors.NotLocalUrl):
622
branch = bzrdir.open_branch()
625
return tree, branch, relpath
627
def open_repository(self, _unsupported=False):
628
"""Open the repository object at this BzrDir if one is present.
630
This will not follow the Branch object pointer - its strictly a direct
631
open facility. Most client code should use open_branch().repository to
634
_unsupported is a private parameter, not part of the api.
635
TODO: static convenience version of this?
637
raise NotImplementedError(self.open_repository)
639
def open_workingtree(self, _unsupported=False):
640
"""Open the workingtree object at this BzrDir if one is present.
642
TODO: static convenience version of this?
644
raise NotImplementedError(self.open_workingtree)
646
def has_branch(self):
647
"""Tell if this bzrdir contains a branch.
649
Note: if you're going to open the branch, you should just go ahead
650
and try, and not ask permission first. (This method just opens the
651
branch and discards it, and that's somewhat expensive.)
656
except errors.NotBranchError:
659
def has_workingtree(self):
660
"""Tell if this bzrdir contains a working tree.
662
This will still raise an exception if the bzrdir has a workingtree that
663
is remote & inaccessible.
665
Note: if you're going to open the working tree, you should just go ahead
666
and try, and not ask permission first. (This method just opens the
667
workingtree and discards it, and that's somewhat expensive.)
670
self.open_workingtree(recommend_upgrade=False)
672
except errors.NoWorkingTree:
669
675
def _cloning_metadir(self):
670
"""Produce a metadir suitable for cloning with.
672
:returns: (destination_bzrdir_format, source_repository)
674
676
result_format = self._format.__class__()
677
branch = self.open_branch(ignore_fallbacks=True)
679
branch = self.open_branch()
678
680
source_repository = branch.repository
679
result_format._branch_format = branch._format
680
681
except errors.NotBranchError:
681
683
source_repository = self.open_repository()
684
result_format.repository_format = source_repository._format
682
685
except errors.NoRepositoryPresent:
683
686
source_repository = None
685
# XXX TODO: This isinstance is here because we have not implemented
686
# the fix recommended in bug # 103195 - to delegate this choice the
688
repo_format = source_repository._format
689
if isinstance(repo_format, remote.RemoteRepositoryFormat):
690
source_repository._ensure_real()
691
repo_format = source_repository._real_repository._format
692
result_format.repository_format = repo_format
694
688
# TODO: Couldn't we just probe for the format in these cases,
695
689
# rather than opening the whole tree? It would be a little
701
695
result_format.workingtree_format = tree._format.__class__()
702
696
return result_format, source_repository
704
def cloning_metadir(self, require_stacking=False):
698
def cloning_metadir(self):
705
699
"""Produce a metadir suitable for cloning or sprouting with.
707
701
These operations may produce workingtrees (yes, even though they're
708
"cloning" something that doesn't have a tree), so a viable workingtree
702
"cloning" something that doesn't have a tree, so a viable workingtree
709
703
format must be selected.
711
:require_stacking: If True, non-stackable formats will be upgraded
712
to similar stackable formats.
713
:returns: a ControlDirFormat with all component formats either set
714
appropriately or set to None if that component should not be
717
705
format, repository = self._cloning_metadir()
718
706
if format._workingtree_format is None:
720
707
if repository is None:
721
# No repository either
723
# We have a repository, so set a working tree? (Why? This seems to
724
# contradict the stated return value in the docstring).
726
repository._format._matchingcontroldir.workingtree_format)
709
tree_format = repository._format._matchingbzrdir.workingtree_format
727
710
format.workingtree_format = tree_format.__class__()
729
format.require_stacking()
732
def get_branch_transport(self, branch_format, name=None):
733
"""Get the transport for use by branch format in this BzrDir.
735
Note that bzr dirs that do not support format strings will raise
736
IncompatibleFormat if the branch format they are given has
737
a format string, and vice versa.
739
If branch_format is None, the transport is returned with no
740
checking. If it is not None, then the returned transport is
741
guaranteed to point to an existing directory ready for use.
713
def checkout_metadir(self):
714
return self.cloning_metadir()
716
def sprout(self, url, revision_id=None, force_new_repo=False,
718
"""Create a copy of this bzrdir prepared for use as a new line of
721
If urls last component does not exist, it will be created.
723
Attributes related to the identity of the source branch like
724
branch nickname will be cleaned, a working tree is created
725
whether one existed before or not; and a local branch is always
728
if revision_id is not None, then the clone operation may tune
729
itself to download less data.
743
raise NotImplementedError(self.get_branch_transport)
732
cloning_format = self.cloning_metadir()
733
result = cloning_format.initialize(url)
735
source_branch = self.open_branch()
736
source_repository = source_branch.repository
737
except errors.NotBranchError:
740
source_repository = self.open_repository()
741
except errors.NoRepositoryPresent:
742
source_repository = None
747
result_repo = result.find_repository()
748
except errors.NoRepositoryPresent:
750
if source_repository is None and result_repo is not None:
752
elif source_repository is None and result_repo is None:
753
# no repo available, make a new one
754
result.create_repository()
755
elif source_repository is not None and result_repo is None:
756
# have source, and want to make a new target repo
757
# we don't clone the repo because that preserves attributes
758
# like is_shared(), and we have not yet implemented a
759
# repository sprout().
760
result_repo = result.create_repository()
761
if result_repo is not None:
762
# fetch needed content into target.
763
if source_repository is not None:
764
result_repo.fetch(source_repository, revision_id=revision_id)
765
if source_branch is not None:
766
source_branch.sprout(result, revision_id=revision_id)
768
result.create_branch()
769
# TODO: jam 20060426 we probably need a test in here in the
770
# case that the newly sprouted branch is a remote one
771
if result_repo is None or result_repo.make_working_trees():
772
wt = result.create_workingtree()
775
if wt.path2id('') is None:
777
wt.set_root_id(self.open_workingtree.get_root_id())
778
except errors.NoWorkingTree:
784
if recurse == 'down':
786
basis = wt.basis_tree()
788
subtrees = basis.iter_references()
789
recurse_branch = wt.branch
790
elif source_branch is not None:
791
basis = source_branch.basis_tree()
793
subtrees = basis.iter_references()
794
recurse_branch = source_branch
799
for path, file_id in subtrees:
800
target = urlutils.join(url, urlutils.escape(path))
801
sublocation = source_branch.reference_parent(file_id, path)
802
sublocation.bzrdir.sprout(target,
803
basis.get_reference_revision(file_id, path),
804
force_new_repo=force_new_repo, recurse=recurse)
806
if basis is not None:
811
class BzrDirPreSplitOut(BzrDir):
812
"""A common class for the all-in-one formats."""
814
def __init__(self, _transport, _format):
815
"""See BzrDir.__init__."""
816
super(BzrDirPreSplitOut, self).__init__(_transport, _format)
817
assert self._format._lock_class == lockable_files.TransportLock
818
assert self._format._lock_file_name == 'branch-lock'
819
self._control_files = lockable_files.LockableFiles(
820
self.get_branch_transport(None),
821
self._format._lock_file_name,
822
self._format._lock_class)
824
def break_lock(self):
825
"""Pre-splitout bzrdirs do not suffer from stale locks."""
826
raise NotImplementedError(self.break_lock)
828
def clone(self, url, revision_id=None, force_new_repo=False):
829
"""See BzrDir.clone()."""
830
from bzrlib.workingtree import WorkingTreeFormat2
832
result = self._format._initialize_for_clone(url)
833
self.open_repository().clone(result, revision_id=revision_id)
834
from_branch = self.open_branch()
835
from_branch.clone(result, revision_id=revision_id)
837
self.open_workingtree().clone(result)
838
except errors.NotLocalUrl:
839
# make a new one, this format always has to have one.
841
WorkingTreeFormat2().initialize(result)
842
except errors.NotLocalUrl:
843
# but we cannot do it for remote trees.
844
to_branch = result.open_branch()
845
WorkingTreeFormat2().stub_initialize_remote(to_branch.control_files)
848
def create_branch(self):
849
"""See BzrDir.create_branch."""
850
return self.open_branch()
852
def create_repository(self, shared=False):
853
"""See BzrDir.create_repository."""
855
raise errors.IncompatibleFormat('shared repository', self._format)
856
return self.open_repository()
858
def create_workingtree(self, revision_id=None):
859
"""See BzrDir.create_workingtree."""
860
# this looks buggy but is not -really-
861
# because this format creates the workingtree when the bzrdir is
863
# clone and sprout will have set the revision_id
864
# and that will have set it for us, its only
865
# specific uses of create_workingtree in isolation
866
# that can do wonky stuff here, and that only
867
# happens for creating checkouts, which cannot be
868
# done on this format anyway. So - acceptable wart.
869
result = self.open_workingtree(recommend_upgrade=False)
870
if revision_id is not None:
871
if revision_id == _mod_revision.NULL_REVISION:
872
result.set_parent_ids([])
874
result.set_parent_ids([revision_id])
877
def destroy_workingtree(self):
878
"""See BzrDir.destroy_workingtree."""
879
raise errors.UnsupportedOperation(self.destroy_workingtree, self)
881
def destroy_workingtree_metadata(self):
882
"""See BzrDir.destroy_workingtree_metadata."""
883
raise errors.UnsupportedOperation(self.destroy_workingtree_metadata,
886
def get_branch_transport(self, branch_format):
887
"""See BzrDir.get_branch_transport()."""
888
if branch_format is None:
889
return self.transport
891
branch_format.get_format_string()
892
except NotImplementedError:
893
return self.transport
894
raise errors.IncompatibleFormat(branch_format, self._format)
745
896
def get_repository_transport(self, repository_format):
746
"""Get the transport for use by repository format in this BzrDir.
748
Note that bzr dirs that do not support format strings will raise
749
IncompatibleFormat if the repository format they are given has
750
a format string, and vice versa.
752
If repository_format is None, the transport is returned with no
753
checking. If it is not None, then the returned transport is
754
guaranteed to point to an existing directory ready for use.
756
raise NotImplementedError(self.get_repository_transport)
758
def get_workingtree_transport(self, tree_format):
759
"""Get the transport for use by workingtree format in this BzrDir.
761
Note that bzr dirs that do not support format strings will raise
762
IncompatibleFormat if the workingtree format they are given has a
763
format string, and vice versa.
765
If workingtree_format is None, the transport is returned with no
766
checking. If it is not None, then the returned transport is
767
guaranteed to point to an existing directory ready for use.
769
raise NotImplementedError(self.get_workingtree_transport)
772
def create(cls, base, format=None, possible_transports=None):
773
"""Create a new BzrDir at the url 'base'.
775
:param format: If supplied, the format of branch to create. If not
776
supplied, the default is used.
777
:param possible_transports: If supplied, a list of transports that
778
can be reused to share a remote connection.
780
if cls is not BzrDir:
781
raise AssertionError("BzrDir.create always creates the "
782
"default format, not one of %r" % cls)
783
return controldir.ControlDir.create(
784
base, format=format, possible_transports=possible_transports)
787
return "<%s at %r>" % (self.__class__.__name__, self.user_url)
789
def update_feature_flags(self, updated_flags):
790
"""Update the features required by this bzrdir.
792
:param updated_flags: Dictionary mapping feature names to necessities
793
A necessity can be None to indicate the feature should be removed
795
self.control_files.lock_write()
797
self._format._update_feature_flags(updated_flags)
798
self.transport.put_bytes('branch-format', self._format.as_string())
800
self.control_files.unlock()
897
"""See BzrDir.get_repository_transport()."""
898
if repository_format is None:
899
return self.transport
901
repository_format.get_format_string()
902
except NotImplementedError:
903
return self.transport
904
raise errors.IncompatibleFormat(repository_format, self._format)
906
def get_workingtree_transport(self, workingtree_format):
907
"""See BzrDir.get_workingtree_transport()."""
908
if workingtree_format is None:
909
return self.transport
911
workingtree_format.get_format_string()
912
except NotImplementedError:
913
return self.transport
914
raise errors.IncompatibleFormat(workingtree_format, self._format)
916
def needs_format_conversion(self, format=None):
917
"""See BzrDir.needs_format_conversion()."""
918
# if the format is not the same as the system default,
919
# an upgrade is needed.
921
format = BzrDirFormat.get_default_format()
922
return not isinstance(self._format, format.__class__)
924
def open_branch(self, unsupported=False):
925
"""See BzrDir.open_branch."""
926
from bzrlib.branch import BzrBranchFormat4
927
format = BzrBranchFormat4()
928
self._check_supported(format, unsupported)
929
return format.open(self, _found=True)
931
def sprout(self, url, revision_id=None, force_new_repo=False):
932
"""See BzrDir.sprout()."""
933
from bzrlib.workingtree import WorkingTreeFormat2
935
result = self._format._initialize_for_clone(url)
937
self.open_repository().clone(result, revision_id=revision_id)
938
except errors.NoRepositoryPresent:
941
self.open_branch().sprout(result, revision_id=revision_id)
942
except errors.NotBranchError:
944
# we always want a working tree
945
WorkingTreeFormat2().initialize(result)
949
class BzrDir4(BzrDirPreSplitOut):
950
"""A .bzr version 4 control object.
952
This is a deprecated format and may be removed after sept 2006.
955
def create_repository(self, shared=False):
956
"""See BzrDir.create_repository."""
957
return self._format.repository_format.initialize(self, shared)
959
def needs_format_conversion(self, format=None):
960
"""Format 4 dirs are always in need of conversion."""
963
def open_repository(self):
964
"""See BzrDir.open_repository."""
965
from bzrlib.repofmt.weaverepo import RepositoryFormat4
966
return RepositoryFormat4().open(self, _found=True)
969
class BzrDir5(BzrDirPreSplitOut):
970
"""A .bzr version 5 control object.
972
This is a deprecated format and may be removed after sept 2006.
975
def open_repository(self):
976
"""See BzrDir.open_repository."""
977
from bzrlib.repofmt.weaverepo import RepositoryFormat5
978
return RepositoryFormat5().open(self, _found=True)
980
def open_workingtree(self, _unsupported=False,
981
recommend_upgrade=True):
982
"""See BzrDir.create_workingtree."""
983
from bzrlib.workingtree import WorkingTreeFormat2
984
wt_format = WorkingTreeFormat2()
985
# we don't warn here about upgrades; that ought to be handled for the
987
return wt_format.open(self, _found=True)
990
class BzrDir6(BzrDirPreSplitOut):
991
"""A .bzr version 6 control object.
993
This is a deprecated format and may be removed after sept 2006.
996
def open_repository(self):
997
"""See BzrDir.open_repository."""
998
from bzrlib.repofmt.weaverepo import RepositoryFormat6
999
return RepositoryFormat6().open(self, _found=True)
1001
def open_workingtree(self, _unsupported=False,
1002
recommend_upgrade=True):
1003
"""See BzrDir.create_workingtree."""
1004
# we don't warn here about upgrades; that ought to be handled for the
1006
from bzrlib.workingtree import WorkingTreeFormat2
1007
return WorkingTreeFormat2().open(self, _found=True)
803
1010
class BzrDirMeta1(BzrDir):
804
1011
"""A .bzr meta version 1 control object.
806
This is the first control object where the
1013
This is the first control object where the
807
1014
individual aspects are really split out: there are separate repository,
808
1015
workingtree and branch subdirectories and any subset of the three can be
809
1016
present within a BzrDir.
812
def _get_branch_path(self, name):
813
"""Obtain the branch path to use.
815
This uses the API specified branch name first, and then falls back to
816
the branch name specified in the URL. If neither of those is specified,
817
it uses the default branch.
819
:param name: Optional branch name to use
820
:return: Relative path to branch
824
return urlutils.join('branches', urlutils.escape(name))
826
def _read_branch_list(self):
827
"""Read the branch list.
829
:return: List of branch names.
832
f = self.control_transport.get('branch-list')
833
except errors.NoSuchFile:
839
ret.append(name.rstrip(b"\n").decode('utf-8'))
844
def _write_branch_list(self, branches):
845
"""Write out the branch list.
847
:param branches: List of utf-8 branch names to write
849
self.transport.put_bytes(
851
b"".join([name.encode('utf-8') + b"\n" for name in branches]))
853
def __init__(self, _transport, _format):
854
super(BzrDirMeta1, self).__init__(_transport, _format)
855
self.control_files = lockable_files.LockableFiles(
856
self.control_transport, self._format._lock_file_name,
857
self._format._lock_class)
859
1019
def can_convert_format(self):
860
1020
"""See BzrDir.can_convert_format()."""
863
def create_branch(self, name=None, repository=None,
864
append_revisions_only=None):
865
"""See ControlDir.create_branch."""
867
name = self._get_selected_branch()
868
return self._format.get_branch_format().initialize(
869
self, name=name, repository=repository,
870
append_revisions_only=append_revisions_only)
872
def destroy_branch(self, name=None):
873
"""See ControlDir.destroy_branch."""
875
name = self._get_selected_branch()
876
path = self._get_branch_path(name)
878
self.control_files.lock_write()
880
branches = self._read_branch_list()
882
branches.remove(name)
884
raise errors.NotBranchError(name)
885
self._write_branch_list(branches)
887
self.control_files.unlock()
889
self.transport.delete_tree(path)
890
except errors.NoSuchFile:
891
raise errors.NotBranchError(
892
path=urlutils.join(self.transport.base, path), controldir=self)
1023
def create_branch(self):
1024
"""See BzrDir.create_branch."""
1025
return self._format.get_branch_format().initialize(self)
894
1027
def create_repository(self, shared=False):
895
1028
"""See BzrDir.create_repository."""
896
1029
return self._format.repository_format.initialize(self, shared)
898
def destroy_repository(self):
899
"""See BzrDir.destroy_repository."""
901
self.transport.delete_tree('repository')
902
except errors.NoSuchFile:
903
raise errors.NoRepositoryPresent(self)
905
def create_workingtree(self, revision_id=None, from_branch=None,
906
accelerator_tree=None, hardlink=False):
1031
def create_workingtree(self, revision_id=None):
907
1032
"""See BzrDir.create_workingtree."""
908
return self._format.workingtree_format.initialize(
909
self, revision_id, from_branch=from_branch,
910
accelerator_tree=accelerator_tree, hardlink=hardlink)
1033
from bzrlib.workingtree import WorkingTreeFormat
1034
return self._format.workingtree_format.initialize(self, revision_id)
912
1036
def destroy_workingtree(self):
913
1037
"""See BzrDir.destroy_workingtree."""
914
1038
wt = self.open_workingtree(recommend_upgrade=False)
915
1039
repository = wt.branch.repository
916
1040
empty = repository.revision_tree(_mod_revision.NULL_REVISION)
917
# We ignore the conflicts returned by wt.revert since we're about to
918
# delete the wt metadata anyway, all that should be left here are
919
# detritus. But see bug #634470 about subtree .bzr dirs.
920
wt.revert(old_tree=empty)
1041
wt.revert([], old_tree=empty)
921
1042
self.destroy_workingtree_metadata()
923
1044
def destroy_workingtree_metadata(self):
924
1045
self.transport.delete_tree('checkout')
926
def find_branch_format(self, name=None):
927
"""Find the branch 'format' for this bzrdir.
929
This might be a synthetic object for e.g. RemoteBranch and SVN.
931
from .branch import BranchFormatMetadir
932
return BranchFormatMetadir.find_format(self, name=name)
934
1047
def _get_mkdir_mode(self):
935
1048
"""Figure out the mode to use when creating a bzrdir subdir."""
936
temp_control = lockable_files.LockableFiles(
937
self.transport, '', lockable_files.TransportLock)
1049
temp_control = lockable_files.LockableFiles(self.transport, '',
1050
lockable_files.TransportLock)
938
1051
return temp_control._dir_mode
940
def get_branch_reference(self, name=None):
941
"""See BzrDir.get_branch_reference()."""
942
from .branch import BranchFormatMetadir
943
format = BranchFormatMetadir.find_format(self, name=name)
944
return format.get_reference(self, name=name)
946
def set_branch_reference(self, target_branch, name=None):
947
format = _mod_bzrbranch.BranchReferenceFormat()
948
if (self.control_url == target_branch.controldir.control_url
949
and name == target_branch.name):
950
raise controldir.BranchReferenceLoop(target_branch)
951
return format.initialize(self, target_branch=target_branch, name=name)
953
def get_branch_transport(self, branch_format, name=None):
1053
def get_branch_transport(self, branch_format):
954
1054
"""See BzrDir.get_branch_transport()."""
956
name = self._get_selected_branch()
957
path = self._get_branch_path(name)
958
# XXX: this shouldn't implicitly create the directory if it's just
959
# promising to get a transport -- mbp 20090727
960
1055
if branch_format is None:
961
return self.transport.clone(path)
1056
return self.transport.clone('branch')
963
1058
branch_format.get_format_string()
964
1059
except NotImplementedError:
965
1060
raise errors.IncompatibleFormat(branch_format, self._format)
967
branches = self._read_branch_list()
968
if name not in branches:
969
self.control_files.lock_write()
971
branches = self._read_branch_list()
972
dirname = urlutils.dirname(name)
973
if dirname != u"" and dirname in branches:
974
raise errors.ParentBranchExists(name)
976
b.startswith(name + u"/") for b in branches]
977
if any(child_branches):
978
raise errors.AlreadyBranchError(name)
979
branches.append(name)
980
self._write_branch_list(branches)
982
self.control_files.unlock()
983
branch_transport = self.transport.clone(path)
984
mode = self._get_mkdir_mode()
985
branch_transport.create_prefix(mode=mode)
987
self.transport.mkdir(path, mode=mode)
1062
self.transport.mkdir('branch', mode=self._get_mkdir_mode())
988
1063
except errors.FileExists:
990
return self.transport.clone(path)
1065
return self.transport.clone('branch')
992
1067
def get_repository_transport(self, repository_format):
993
1068
"""See BzrDir.get_repository_transport()."""
1087
def open_branch(self, name=None, unsupported=False,
1088
ignore_fallbacks=False, possible_transports=None):
1089
"""See ControlDir.open_branch."""
1091
name = self._get_selected_branch()
1092
format = self.find_branch_format(name=name)
1093
format.check_support_status(unsupported)
1094
if possible_transports is None:
1095
possible_transports = []
1097
possible_transports = list(possible_transports)
1098
possible_transports.append(self.root_transport)
1099
return format.open(self, name=name,
1100
_found=True, ignore_fallbacks=ignore_fallbacks,
1101
possible_transports=possible_transports)
1127
def open_branch(self, unsupported=False):
1128
"""See BzrDir.open_branch."""
1129
from bzrlib.branch import BranchFormat
1130
format = BranchFormat.find_format(self)
1131
self._check_supported(format, unsupported)
1132
return format.open(self, _found=True)
1103
1134
def open_repository(self, unsupported=False):
1104
1135
"""See BzrDir.open_repository."""
1105
from .repository import RepositoryFormatMetaDir
1106
format = RepositoryFormatMetaDir.find_format(self)
1107
format.check_support_status(unsupported)
1136
from bzrlib.repository import RepositoryFormat
1137
format = RepositoryFormat.find_format(self)
1138
self._check_supported(format, unsupported)
1108
1139
return format.open(self, _found=True)
1110
1141
def open_workingtree(self, unsupported=False,
1111
recommend_upgrade=True):
1142
recommend_upgrade=True):
1112
1143
"""See BzrDir.open_workingtree."""
1113
from .workingtree import WorkingTreeFormatMetaDir
1114
format = WorkingTreeFormatMetaDir.find_format(self)
1115
format.check_support_status(unsupported, recommend_upgrade,
1116
basedir=self.root_transport.base)
1144
from bzrlib.workingtree import WorkingTreeFormat
1145
format = WorkingTreeFormat.find_format(self)
1146
self._check_supported(format, unsupported,
1148
basedir=self.root_transport.base)
1117
1149
return format.open(self, _found=True)
1119
def _get_config(self):
1120
return config.TransportConfig(self.transport, 'control.conf')
1123
class BzrFormat(object):
1124
"""Base class for all formats of things living in metadirs.
1126
This class manages the format string that is stored in the 'format'
1127
or 'branch-format' file.
1129
All classes for (branch-, repository-, workingtree-) formats that
1130
live in meta directories and have their own 'format' file
1131
(i.e. different from .bzr/branch-format) derive from this class,
1132
as well as the relevant base class for their kind
1133
(BranchFormat, WorkingTreeFormat, RepositoryFormat).
1135
Each format is identified by a "format" or "branch-format" file with a
1136
single line containing the base format name and then an optional list of
1139
Feature flags are supported as of bzr 2.5. Setting feature flags on formats
1140
will render them inaccessible to older versions of bzr.
1142
:ivar features: Dictionary mapping feature names to their necessity
1145
_present_features = set()
1151
def register_feature(cls, name):
1152
"""Register a feature as being present.
1154
:param name: Name of the feature
1157
raise ValueError("spaces are not allowed in feature names")
1158
if name in cls._present_features:
1159
raise FeatureAlreadyRegistered(name)
1160
cls._present_features.add(name)
1163
def unregister_feature(cls, name):
1164
"""Unregister a feature."""
1165
cls._present_features.remove(name)
1167
def check_support_status(self, allow_unsupported, recommend_upgrade=True,
1169
for name, necessity in self.features.items():
1170
if name in self._present_features:
1172
if necessity == b"optional":
1173
mutter("ignoring optional missing feature %s", name)
1175
elif necessity == b"required":
1176
raise MissingFeature(name)
1178
mutter("treating unknown necessity as require for %s",
1180
raise MissingFeature(name)
1183
def get_format_string(cls):
1184
"""Return the ASCII format string that identifies this format."""
1185
raise NotImplementedError(cls.get_format_string)
1188
def from_string(cls, text):
1189
format_string = cls.get_format_string()
1190
if not text.startswith(format_string):
1191
raise AssertionError(
1192
"Invalid format header %r for %r" % (text, cls))
1193
lines = text[len(format_string):].splitlines()
1195
for lineno, line in enumerate(lines):
1197
(necessity, feature) = line.split(b" ", 1)
1199
raise errors.ParseFormatError(format=cls, lineno=lineno + 2,
1200
line=line, text=text)
1201
ret.features[feature] = necessity
1204
def as_string(self):
1205
"""Return the string representation of this format.
1207
lines = [self.get_format_string()]
1208
lines.extend([(item[1] + b" " + item[0] + b"\n")
1209
for item in sorted(self.features.items())])
1210
return b"".join(lines)
1213
def _find_format(klass, registry, kind, format_string):
1215
first_line = format_string[:format_string.index(b"\n") + 1]
1217
first_line = format_string
1219
cls = registry.get(first_line)
1221
raise errors.UnknownFormatError(format=first_line, kind=kind)
1222
return cls.from_string(format_string)
1224
def network_name(self):
1225
"""A simple byte string uniquely identifying this format for RPC calls.
1227
Metadir branch formats use their format string.
1229
return self.as_string()
1231
def __eq__(self, other):
1232
return (self.__class__ is other.__class__
1233
and self.features == other.features)
1235
def _update_feature_flags(self, updated_flags):
1236
"""Update the feature flags in this format.
1238
:param updated_flags: Updated feature flags
1240
for name, necessity in updated_flags.items():
1241
if necessity is None:
1243
del self.features[name]
1247
self.features[name] = necessity
1250
class BzrDirFormat(BzrFormat, controldir.ControlDirFormat):
1251
"""ControlDirFormat base class for .bzr/ directories.
1253
Formats are placed in a dict by their format string for reference
1152
class BzrDirFormat(object):
1153
"""An encapsulation of the initialization and open routines for a format.
1155
Formats provide three things:
1156
* An initialization routine,
1160
Formats are placed in an dict by their format string for reference
1254
1161
during bzrdir opening. These should be subclasses of BzrDirFormat
1255
1162
for consistency.
1257
1164
Once a format is deprecated, just deprecate the initialize and open
1258
methods on the format class. Do not deprecate the object, as the
1165
methods on the format class. Do not deprecate the object, as the
1259
1166
object will be created every system load.
1169
_default_format = None
1170
"""The default format used for new .bzr dirs."""
1173
"""The known formats."""
1175
_control_formats = []
1176
"""The registered control formats - .bzr, ....
1178
This is a list of BzrDirFormat objects.
1262
1181
_lock_file_name = 'branch-lock'
1264
1183
# _lock_class must be set in subclasses to the lock type, typ.
1265
1184
# TransportLock or LockDir
1187
def find_format(klass, transport):
1188
"""Return the format present at transport."""
1189
for format in klass._control_formats:
1191
return format.probe_transport(transport)
1192
except errors.NotBranchError:
1193
# this format does not find a control dir here.
1195
raise errors.NotBranchError(path=transport.base)
1198
def probe_transport(klass, transport):
1199
"""Return the .bzrdir style transport present at URL."""
1201
format_string = transport.get(".bzr/branch-format").read()
1202
except errors.NoSuchFile:
1203
raise errors.NotBranchError(path=transport.base)
1206
return klass._formats[format_string]
1208
raise errors.UnknownFormatError(format=format_string)
1211
def get_default_format(klass):
1212
"""Return the current default format."""
1213
return klass._default_format
1215
def get_format_string(self):
1216
"""Return the ASCII format string that identifies this format."""
1217
raise NotImplementedError(self.get_format_string)
1219
def get_format_description(self):
1220
"""Return the short description for this format."""
1221
raise NotImplementedError(self.get_format_description)
1223
def get_converter(self, format=None):
1224
"""Return the converter to use to convert bzrdirs needing converts.
1226
This returns a bzrlib.bzrdir.Converter object.
1228
This should return the best upgrader to step this format towards the
1229
current default format. In the case of plugins we can/should provide
1230
some means for them to extend the range of returnable converters.
1232
:param format: Optional format to override the default format of the
1235
raise NotImplementedError(self.get_converter)
1237
def initialize(self, url):
1238
"""Create a bzr control dir at this url and return an opened copy.
1240
Subclasses should typically override initialize_on_transport
1241
instead of this method.
1243
return self.initialize_on_transport(get_transport(url))
1267
1245
def initialize_on_transport(self, transport):
1268
1246
"""Initialize a new bzrdir in the base directory of a Transport."""
1270
# can we hand off the request to the smart server rather than using
1272
client_medium = transport.get_smart_medium()
1273
except errors.NoSmartMedium:
1274
return self._initialize_on_transport_vfs(transport)
1276
# Current RPC's only know how to create bzr metadir1 instances, so
1277
# we still delegate to vfs methods if the requested format is not a
1279
if not isinstance(self, BzrDirMetaFormat1):
1280
return self._initialize_on_transport_vfs(transport)
1281
from .remote import RemoteBzrDirFormat
1282
remote_format = RemoteBzrDirFormat()
1283
self._supply_sub_formats_to(remote_format)
1284
return remote_format.initialize_on_transport(transport)
1286
def initialize_on_transport_ex(self, transport, use_existing_dir=False,
1287
create_prefix=False, force_new_repo=False, stacked_on=None,
1288
stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
1289
shared_repo=False, vfs_only=False):
1290
"""Create this format on transport.
1292
The directory to initialize will be created.
1294
:param force_new_repo: Do not use a shared repository for the target,
1295
even if one is available.
1296
:param create_prefix: Create any missing directories leading up to
1298
:param use_existing_dir: Use an existing directory if one exists.
1299
:param stacked_on: A url to stack any created branch on, None to follow
1300
any target stacking policy.
1301
:param stack_on_pwd: If stack_on is relative, the location it is
1303
:param repo_format_name: If non-None, a repository will be
1304
made-or-found. Should none be found, or if force_new_repo is True
1305
the repo_format_name is used to select the format of repository to
1307
:param make_working_trees: Control the setting of make_working_trees
1308
for a new shared repository when one is made. None to use whatever
1309
default the format has.
1310
:param shared_repo: Control whether made repositories are shared or
1312
:param vfs_only: If True do not attempt to use a smart server
1313
:return: repo, controldir, require_stacking, repository_policy. repo is
1314
None if none was created or found, bzrdir is always valid.
1315
require_stacking is the result of examining the stacked_on
1316
parameter and any stacking policy found for the target.
1319
# Try to hand off to a smart server
1321
client_medium = transport.get_smart_medium()
1322
except errors.NoSmartMedium:
1325
from .remote import RemoteBzrDirFormat
1326
# TODO: lookup the local format from a server hint.
1327
remote_dir_format = RemoteBzrDirFormat()
1328
remote_dir_format._network_name = self.network_name()
1329
self._supply_sub_formats_to(remote_dir_format)
1330
return remote_dir_format.initialize_on_transport_ex(
1331
transport, use_existing_dir=use_existing_dir,
1332
create_prefix=create_prefix, force_new_repo=force_new_repo,
1333
stacked_on=stacked_on, stack_on_pwd=stack_on_pwd,
1334
repo_format_name=repo_format_name,
1335
make_working_trees=make_working_trees,
1336
shared_repo=shared_repo)
1337
# XXX: Refactor the create_prefix/no_create_prefix code into a
1338
# common helper function
1339
# The destination may not exist - if so make it according to policy.
1341
def make_directory(transport):
1342
transport.mkdir('.')
1345
def redirected(transport, e, redirection_notice):
1346
note(redirection_notice)
1347
return transport._redirected_to(e.source, e.target)
1349
transport = do_catching_redirections(make_directory, transport,
1351
except errors.FileExists:
1352
if not use_existing_dir:
1354
except errors.NoSuchFile:
1355
if not create_prefix:
1357
transport.create_prefix()
1359
require_stacking = (stacked_on is not None)
1360
# Now the target directory exists, but doesn't have a .bzr
1361
# directory. So we need to create it, along with any work to create
1362
# all of the dependent branches, etc.
1364
result = self.initialize_on_transport(transport)
1365
if repo_format_name:
1367
# use a custom format
1368
result._format.repository_format = \
1369
repository.network_format_registry.get(repo_format_name)
1370
except AttributeError:
1371
# The format didn't permit it to be set.
1373
# A repository is desired, either in-place or shared.
1374
repository_policy = result.determine_repository_policy(
1375
force_new_repo, stacked_on, stack_on_pwd,
1376
require_stacking=require_stacking)
1377
result_repo, is_new_repo = repository_policy.acquire_repository(
1378
make_working_trees, shared_repo)
1379
if not require_stacking and repository_policy._require_stacking:
1380
require_stacking = True
1381
result._format.require_stacking()
1382
result_repo.lock_write()
1385
repository_policy = None
1386
return result_repo, result, require_stacking, repository_policy
1388
def _initialize_on_transport_vfs(self, transport):
1389
"""Initialize a new bzrdir using VFS calls.
1391
:param transport: The transport to create the .bzr directory in.
1394
# Since we are creating a .bzr directory, inherit the
1247
# Since we don't have a .bzr directory, inherit the
1395
1248
# mode from the root directory
1396
1249
temp_control = lockable_files.LockableFiles(transport,
1397
'', lockable_files.TransportLock)
1399
temp_control._transport.mkdir('.bzr',
1400
# FIXME: RBC 20060121 don't peek under
1402
mode=temp_control._dir_mode)
1403
except errors.FileExists:
1404
raise errors.AlreadyControlDirError(transport.base)
1405
if sys.platform == 'win32' and isinstance(transport, local.LocalTransport):
1406
win32utils.set_file_attr_hidden(transport._abspath('.bzr'))
1250
'', lockable_files.TransportLock)
1251
temp_control._transport.mkdir('.bzr',
1252
# FIXME: RBC 20060121 don't peek under
1254
mode=temp_control._dir_mode)
1407
1255
file_mode = temp_control._file_mode
1408
1256
del temp_control
1409
bzrdir_transport = transport.clone('.bzr')
1410
utf8_files = [('README',
1411
b"This is a Bazaar control directory.\n"
1412
b"Do not change any files in this directory.\n"
1413
b"See http://bazaar.canonical.com/ for more information about Bazaar.\n"),
1414
('branch-format', self.as_string()),
1257
mutter('created control directory in ' + transport.base)
1258
control = transport.clone('.bzr')
1259
utf8_files = [('README',
1260
"This is a Bazaar-NG control directory.\n"
1261
"Do not change any files in this directory.\n"),
1262
('branch-format', self.get_format_string()),
1416
1264
# NB: no need to escape relative paths that are url safe.
1417
control_files = lockable_files.LockableFiles(bzrdir_transport,
1418
self._lock_file_name, self._lock_class)
1265
control_files = lockable_files.LockableFiles(control,
1266
self._lock_file_name, self._lock_class)
1419
1267
control_files.create_lock()
1420
1268
control_files.lock_write()
1422
for (filename, content) in utf8_files:
1423
bzrdir_transport.put_bytes(filename, content,
1270
for file, content in utf8_files:
1271
control_files.put_utf8(file, content)
1426
1273
control_files.unlock()
1427
1274
return self.open(transport, _found=True)
1276
def is_supported(self):
1277
"""Is this format supported?
1279
Supported formats must be initializable and openable.
1280
Unsupported formats may not support initialization or committing or
1281
some other features depending on the reason for not being supported.
1285
def same_model(self, target_format):
1286
return (self.repository_format.rich_root_data ==
1287
target_format.rich_root_data)
1290
def known_formats(klass):
1291
"""Return all the known formats.
1293
Concrete formats should override _known_formats.
1295
# There is double indirection here to make sure that control
1296
# formats used by more than one dir format will only be probed
1297
# once. This can otherwise be quite expensive for remote connections.
1299
for format in klass._control_formats:
1300
result.update(format._known_formats())
1304
def _known_formats(klass):
1305
"""Return the known format instances for this control format."""
1306
return set(klass._formats.values())
1429
1308
def open(self, transport, _found=False):
1430
1309
"""Return an instance of this format for the dir transport points at.
1432
1311
_found is a private parameter, do not use it.
1435
found_format = controldir.ControlDirFormat.find_format(transport)
1314
found_format = BzrDirFormat.find_format(transport)
1436
1315
if not isinstance(found_format, self.__class__):
1437
1316
raise AssertionError("%s was asked to open %s, but it seems to need "
1439
% (self, transport, found_format))
1440
# Allow subclasses - use the found format.
1441
self._supply_sub_formats_to(found_format)
1442
return found_format._open(transport)
1318
% (self, transport, found_format))
1443
1319
return self._open(transport)
1445
1321
def _open(self, transport):
1451
1327
raise NotImplementedError(self._open)
1453
def _supply_sub_formats_to(self, other_format):
1454
"""Give other_format the same values for sub formats as this has.
1456
This method is expected to be used when parameterising a
1457
RemoteBzrDirFormat instance with the parameters from a
1458
BzrDirMetaFormat1 instance.
1460
:param other_format: other_format is a format which should be
1461
compatible with whatever sub formats are supported by self.
1464
other_format.features = dict(self.features)
1466
def supports_transport(self, transport):
1467
# bzr formats can be opened over all known transports
1470
def check_support_status(self, allow_unsupported, recommend_upgrade=True,
1472
controldir.ControlDirFormat.check_support_status(self,
1473
allow_unsupported=allow_unsupported, recommend_upgrade=recommend_upgrade,
1475
BzrFormat.check_support_status(self, allow_unsupported=allow_unsupported,
1476
recommend_upgrade=recommend_upgrade, basedir=basedir)
1479
def is_control_filename(klass, filename):
1480
"""True if filename is the name of a path which is reserved for bzrdir's.
1482
:param filename: A filename within the root transport of this bzrdir.
1484
This is true IF and ONLY IF the filename is part of the namespace
1485
reserved for bzr control dirs. Currently this is the '.bzr' directory
1486
in the root of the root_transport.
1488
# this might be better on the BzrDirFormat class because it refers to
1489
# all the possible bzrdir disk formats.
1490
# This method is tested via the workingtree is_control_filename tests-
1491
# it was extracted from WorkingTree.is_control_filename. If the
1492
# method's contract is extended beyond the current trivial
1493
# implementation, please add new tests for it to the appropriate place.
1494
return filename == '.bzr' or filename.startswith('.bzr/')
1497
def get_default_format(klass):
1498
"""Return the current default format."""
1499
return controldir.format_registry.get('bzr')()
1330
def register_format(klass, format):
1331
klass._formats[format.get_format_string()] = format
1334
def register_control_format(klass, format):
1335
"""Register a format that does not use '.bzr' for its control dir.
1337
TODO: This should be pulled up into a 'ControlDirFormat' base class
1338
which BzrDirFormat can inherit from, and renamed to register_format
1339
there. It has been done without that for now for simplicity of
1342
klass._control_formats.append(format)
1345
@symbol_versioning.deprecated_method(symbol_versioning.zero_fourteen)
1346
def set_default_format(klass, format):
1347
klass._set_default_format(format)
1350
def _set_default_format(klass, format):
1351
"""Set default format (for testing behavior of defaults only)"""
1352
klass._default_format = format
1355
return self.get_format_string()[:-1]
1358
def unregister_format(klass, format):
1359
assert klass._formats[format.get_format_string()] is format
1360
del klass._formats[format.get_format_string()]
1363
def unregister_control_format(klass, format):
1364
klass._control_formats.remove(format)
1367
class BzrDirFormat4(BzrDirFormat):
1368
"""Bzr dir format 4.
1370
This format is a combined format for working tree, branch and repository.
1372
- Format 1 working trees [always]
1373
- Format 4 branches [always]
1374
- Format 4 repositories [always]
1376
This format is deprecated: it indexes texts using a text it which is
1377
removed in format 5; write support for this format has been removed.
1380
_lock_class = lockable_files.TransportLock
1382
def get_format_string(self):
1383
"""See BzrDirFormat.get_format_string()."""
1384
return "Bazaar-NG branch, format 0.0.4\n"
1386
def get_format_description(self):
1387
"""See BzrDirFormat.get_format_description()."""
1388
return "All-in-one format 4"
1390
def get_converter(self, format=None):
1391
"""See BzrDirFormat.get_converter()."""
1392
# there is one and only one upgrade path here.
1393
return ConvertBzrDir4To5()
1395
def initialize_on_transport(self, transport):
1396
"""Format 4 branches cannot be created."""
1397
raise errors.UninitializableFormat(self)
1399
def is_supported(self):
1400
"""Format 4 is not supported.
1402
It is not supported because the model changed from 4 to 5 and the
1403
conversion logic is expensive - so doing it on the fly was not
1408
def _open(self, transport):
1409
"""See BzrDirFormat._open."""
1410
return BzrDir4(transport, self)
1412
def __return_repository_format(self):
1413
"""Circular import protection."""
1414
from bzrlib.repofmt.weaverepo import RepositoryFormat4
1415
return RepositoryFormat4()
1416
repository_format = property(__return_repository_format)
1419
class BzrDirFormat5(BzrDirFormat):
1420
"""Bzr control format 5.
1422
This format is a combined format for working tree, branch and repository.
1424
- Format 2 working trees [always]
1425
- Format 4 branches [always]
1426
- Format 5 repositories [always]
1427
Unhashed stores in the repository.
1430
_lock_class = lockable_files.TransportLock
1432
def get_format_string(self):
1433
"""See BzrDirFormat.get_format_string()."""
1434
return "Bazaar-NG branch, format 5\n"
1436
def get_format_description(self):
1437
"""See BzrDirFormat.get_format_description()."""
1438
return "All-in-one format 5"
1440
def get_converter(self, format=None):
1441
"""See BzrDirFormat.get_converter()."""
1442
# there is one and only one upgrade path here.
1443
return ConvertBzrDir5To6()
1445
def _initialize_for_clone(self, url):
1446
return self.initialize_on_transport(get_transport(url), _cloning=True)
1448
def initialize_on_transport(self, transport, _cloning=False):
1449
"""Format 5 dirs always have working tree, branch and repository.
1451
Except when they are being cloned.
1453
from bzrlib.branch import BzrBranchFormat4
1454
from bzrlib.repofmt.weaverepo import RepositoryFormat5
1455
from bzrlib.workingtree import WorkingTreeFormat2
1456
result = (super(BzrDirFormat5, self).initialize_on_transport(transport))
1457
RepositoryFormat5().initialize(result, _internal=True)
1459
branch = BzrBranchFormat4().initialize(result)
1461
WorkingTreeFormat2().initialize(result)
1462
except errors.NotLocalUrl:
1463
# Even though we can't access the working tree, we need to
1464
# create its control files.
1465
WorkingTreeFormat2().stub_initialize_remote(branch.control_files)
1468
def _open(self, transport):
1469
"""See BzrDirFormat._open."""
1470
return BzrDir5(transport, self)
1472
def __return_repository_format(self):
1473
"""Circular import protection."""
1474
from bzrlib.repofmt.weaverepo import RepositoryFormat5
1475
return RepositoryFormat5()
1476
repository_format = property(__return_repository_format)
1479
class BzrDirFormat6(BzrDirFormat):
1480
"""Bzr control format 6.
1482
This format is a combined format for working tree, branch and repository.
1484
- Format 2 working trees [always]
1485
- Format 4 branches [always]
1486
- Format 6 repositories [always]
1489
_lock_class = lockable_files.TransportLock
1491
def get_format_string(self):
1492
"""See BzrDirFormat.get_format_string()."""
1493
return "Bazaar-NG branch, format 6\n"
1495
def get_format_description(self):
1496
"""See BzrDirFormat.get_format_description()."""
1497
return "All-in-one format 6"
1499
def get_converter(self, format=None):
1500
"""See BzrDirFormat.get_converter()."""
1501
# there is one and only one upgrade path here.
1502
return ConvertBzrDir6ToMeta()
1504
def _initialize_for_clone(self, url):
1505
return self.initialize_on_transport(get_transport(url), _cloning=True)
1507
def initialize_on_transport(self, transport, _cloning=False):
1508
"""Format 6 dirs always have working tree, branch and repository.
1510
Except when they are being cloned.
1512
from bzrlib.branch import BzrBranchFormat4
1513
from bzrlib.repofmt.weaverepo import RepositoryFormat6
1514
from bzrlib.workingtree import WorkingTreeFormat2
1515
result = super(BzrDirFormat6, self).initialize_on_transport(transport)
1516
RepositoryFormat6().initialize(result, _internal=True)
1518
branch = BzrBranchFormat4().initialize(result)
1520
WorkingTreeFormat2().initialize(result)
1521
except errors.NotLocalUrl:
1522
# Even though we can't access the working tree, we need to
1523
# create its control files.
1524
WorkingTreeFormat2().stub_initialize_remote(branch.control_files)
1527
def _open(self, transport):
1528
"""See BzrDirFormat._open."""
1529
return BzrDir6(transport, self)
1531
def __return_repository_format(self):
1532
"""Circular import protection."""
1533
from bzrlib.repofmt.weaverepo import RepositoryFormat6
1534
return RepositoryFormat6()
1535
repository_format = property(__return_repository_format)
1502
1538
class BzrDirMetaFormat1(BzrDirFormat):
1541
1567
def get_branch_format(self):
1542
1568
if self._branch_format is None:
1543
from .branch import format_registry as branch_format_registry
1544
self._branch_format = branch_format_registry.get_default()
1569
from bzrlib.branch import BranchFormat
1570
self._branch_format = BranchFormat.get_default_format()
1545
1571
return self._branch_format
1547
1573
def set_branch_format(self, format):
1548
1574
self._branch_format = format
1550
def require_stacking(self, stack_on=None, possible_transports=None,
1552
"""We have a request to stack, try to ensure the formats support it.
1554
:param stack_on: If supplied, it is the URL to a branch that we want to
1555
stack on. Check to see if that format supports stacking before
1558
# Stacking is desired. requested by the target, but does the place it
1559
# points at support stacking? If it doesn't then we should
1560
# not implicitly upgrade. We check this here.
1561
new_repo_format = None
1562
new_branch_format = None
1564
# a bit of state for get_target_branch so that we don't try to open it
1565
# 2 times, for both repo *and* branch
1566
target = [None, False, None] # target_branch, checked, upgrade anyway
1568
def get_target_branch():
1570
# We've checked, don't check again
1572
if stack_on is None:
1573
# No target format, that means we want to force upgrading
1574
target[:] = [None, True, True]
1577
target_dir = BzrDir.open(stack_on,
1578
possible_transports=possible_transports)
1579
except errors.NotBranchError:
1580
# Nothing there, don't change formats
1581
target[:] = [None, True, False]
1583
except errors.JailBreak:
1584
# JailBreak, JFDI and upgrade anyway
1585
target[:] = [None, True, True]
1588
target_branch = target_dir.open_branch()
1589
except errors.NotBranchError:
1590
# No branch, don't upgrade formats
1591
target[:] = [None, True, False]
1593
target[:] = [target_branch, True, False]
1597
and not self.repository_format.supports_external_lookups):
1598
# We need to upgrade the Repository.
1599
target_branch, _, do_upgrade = get_target_branch()
1600
if target_branch is None:
1601
# We don't have a target branch, should we upgrade anyway?
1603
# stack_on is inaccessible, JFDI.
1604
# TODO: bad monkey, hard-coded formats...
1605
if self.repository_format.rich_root_data:
1606
new_repo_format = knitpack_repo.RepositoryFormatKnitPack5RichRoot()
1608
new_repo_format = knitpack_repo.RepositoryFormatKnitPack5()
1610
# If the target already supports stacking, then we know the
1611
# project is already able to use stacking, so auto-upgrade
1613
new_repo_format = target_branch.repository._format
1614
if not new_repo_format.supports_external_lookups:
1615
# target doesn't, source doesn't, so don't auto upgrade
1617
new_repo_format = None
1618
if new_repo_format is not None:
1619
self.repository_format = new_repo_format
1620
note(gettext('Source repository format does not support stacking,'
1621
' using format:\n %s'),
1622
new_repo_format.get_format_description())
1624
if not self.get_branch_format().supports_stacking():
1625
# We just checked the repo, now lets check if we need to
1626
# upgrade the branch format
1627
target_branch, _, do_upgrade = get_target_branch()
1628
if target_branch is None:
1630
# TODO: bad monkey, hard-coded formats...
1631
from .branch import BzrBranchFormat7
1632
new_branch_format = BzrBranchFormat7()
1634
new_branch_format = target_branch._format
1635
if not new_branch_format.supports_stacking():
1636
new_branch_format = None
1637
if new_branch_format is not None:
1638
# Does support stacking, use its format.
1639
self.set_branch_format(new_branch_format)
1640
note(gettext('Source branch format does not support stacking,'
1641
' using format:\n %s'),
1642
new_branch_format.get_format_description())
1644
1576
def get_converter(self, format=None):
1645
1577
"""See BzrDirFormat.get_converter()."""
1646
1578
if format is None:
1647
1579
format = BzrDirFormat.get_default_format()
1648
if (isinstance(self, BzrDirMetaFormat1)
1649
and isinstance(format, BzrDirMetaFormat1Colo)):
1650
return ConvertMetaToColo(format)
1651
if (isinstance(self, BzrDirMetaFormat1Colo)
1652
and isinstance(format, BzrDirMetaFormat1)):
1653
return ConvertMetaToColo(format)
1654
1580
if not isinstance(self, format.__class__):
1655
1581
# converting away from metadir is not implemented
1656
1582
raise NotImplementedError(self.get_converter)
1657
1583
return ConvertMetaToMeta(format)
1660
def get_format_string(cls):
1585
def get_format_string(self):
1661
1586
"""See BzrDirFormat.get_format_string()."""
1662
return b"Bazaar-NG meta directory, format 1\n"
1587
return "Bazaar-NG meta directory, format 1\n"
1664
1589
def get_format_description(self):
1665
1590
"""See BzrDirFormat.get_format_description()."""
1668
1593
def _open(self, transport):
1669
1594
"""See BzrDirFormat._open."""
1670
# Create a new format instance because otherwise initialisation of new
1671
# metadirs share the global default format object leading to alias
1673
format = BzrDirMetaFormat1()
1674
self._supply_sub_formats_to(format)
1675
return BzrDirMeta1(transport, format)
1595
return BzrDirMeta1(transport, self)
1677
1597
def __return_repository_format(self):
1678
1598
"""Circular import protection."""
1679
if self._repository_format:
1599
if getattr(self, '_repository_format', None):
1680
1600
return self._repository_format
1681
from .repository import format_registry
1682
return format_registry.get_default()
1601
from bzrlib.repository import RepositoryFormat
1602
return RepositoryFormat.get_default_format()
1684
def _set_repository_format(self, value):
1685
"""Allow changing the repository format for metadir formats."""
1604
def __set_repository_format(self, value):
1605
"""Allow changint the repository format for metadir formats."""
1686
1606
self._repository_format = value
1688
repository_format = property(__return_repository_format,
1689
_set_repository_format)
1691
def _supply_sub_formats_to(self, other_format):
1692
"""Give other_format the same values for sub formats as this has.
1694
This method is expected to be used when parameterising a
1695
RemoteBzrDirFormat instance with the parameters from a
1696
BzrDirMetaFormat1 instance.
1698
:param other_format: other_format is a format which should be
1699
compatible with whatever sub formats are supported by self.
1702
super(BzrDirMetaFormat1, self)._supply_sub_formats_to(other_format)
1703
if getattr(self, '_repository_format', None) is not None:
1704
other_format.repository_format = self.repository_format
1705
if self._branch_format is not None:
1706
other_format._branch_format = self._branch_format
1707
if self._workingtree_format is not None:
1708
other_format.workingtree_format = self.workingtree_format
1608
repository_format = property(__return_repository_format, __set_repository_format)
1710
1610
def __get_workingtree_format(self):
1711
1611
if self._workingtree_format is None:
1712
from .workingtree import (
1713
format_registry as wt_format_registry,
1715
self._workingtree_format = wt_format_registry.get_default()
1612
from bzrlib.workingtree import WorkingTreeFormat
1613
self._workingtree_format = WorkingTreeFormat.get_default_format()
1716
1614
return self._workingtree_format
1718
1616
def __set_workingtree_format(self, wt_format):
1719
1617
self._workingtree_format = wt_format
1722
return "<%r>" % (self.__class__.__name__,)
1724
1619
workingtree_format = property(__get_workingtree_format,
1725
1620
__set_workingtree_format)
1728
class BzrDirMetaFormat1Colo(BzrDirMetaFormat1):
1729
"""BzrDirMeta1 format with support for colocated branches."""
1731
colocated_branches = True
1734
def get_format_string(cls):
1735
"""See BzrDirFormat.get_format_string()."""
1736
return b"Bazaar meta directory, format 1 (with colocated branches)\n"
1738
def get_format_description(self):
1739
"""See BzrDirFormat.get_format_description()."""
1740
return "Meta directory format 1 with support for colocated branches"
1742
def _open(self, transport):
1743
"""See BzrDirFormat._open."""
1744
# Create a new format instance because otherwise initialisation of new
1745
# metadirs share the global default format object leading to alias
1747
format = BzrDirMetaFormat1Colo()
1748
self._supply_sub_formats_to(format)
1749
return BzrDirMeta1(transport, format)
1752
class ConvertMetaToMeta(controldir.Converter):
1623
# Register bzr control format
1624
BzrDirFormat.register_control_format(BzrDirFormat)
1626
# Register bzr formats
1627
BzrDirFormat.register_format(BzrDirFormat4())
1628
BzrDirFormat.register_format(BzrDirFormat5())
1629
BzrDirFormat.register_format(BzrDirFormat6())
1630
__default_format = BzrDirMetaFormat1()
1631
BzrDirFormat.register_format(__default_format)
1632
BzrDirFormat._default_format = __default_format
1635
class BzrDirTestProviderAdapter(object):
1636
"""A tool to generate a suite testing multiple bzrdir formats at once.
1638
This is done by copying the test once for each transport and injecting
1639
the transport_server, transport_readonly_server, and bzrdir_format
1640
classes into each copy. Each copy is also given a new id() to make it
1644
def __init__(self, transport_server, transport_readonly_server, formats):
1645
self._transport_server = transport_server
1646
self._transport_readonly_server = transport_readonly_server
1647
self._formats = formats
1649
def adapt(self, test):
1650
result = unittest.TestSuite()
1651
for format in self._formats:
1652
new_test = deepcopy(test)
1653
new_test.transport_server = self._transport_server
1654
new_test.transport_readonly_server = self._transport_readonly_server
1655
new_test.bzrdir_format = format
1656
def make_new_test_id():
1657
new_id = "%s(%s)" % (new_test.id(), format.__class__.__name__)
1658
return lambda: new_id
1659
new_test.id = make_new_test_id()
1660
result.addTest(new_test)
1664
class Converter(object):
1665
"""Converts a disk format object from one format to another."""
1667
def convert(self, to_convert, pb):
1668
"""Perform the conversion of to_convert, giving feedback via pb.
1670
:param to_convert: The disk object to convert.
1671
:param pb: a progress bar to use for progress information.
1674
def step(self, message):
1675
"""Update the pb by a step."""
1677
self.pb.update(message, self.count, self.total)
1680
class ConvertBzrDir4To5(Converter):
1681
"""Converts format 4 bzr dirs to format 5."""
1684
super(ConvertBzrDir4To5, self).__init__()
1685
self.converted_revs = set()
1686
self.absent_revisions = set()
1690
def convert(self, to_convert, pb):
1691
"""See Converter.convert()."""
1692
self.bzrdir = to_convert
1694
self.pb.note('starting upgrade from format 4 to 5')
1695
if isinstance(self.bzrdir.transport, LocalTransport):
1696
self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
1697
self._convert_to_weaves()
1698
return BzrDir.open(self.bzrdir.root_transport.base)
1700
def _convert_to_weaves(self):
1701
self.pb.note('note: upgrade may be faster if all store files are ungzipped first')
1704
stat = self.bzrdir.transport.stat('weaves')
1705
if not S_ISDIR(stat.st_mode):
1706
self.bzrdir.transport.delete('weaves')
1707
self.bzrdir.transport.mkdir('weaves')
1708
except errors.NoSuchFile:
1709
self.bzrdir.transport.mkdir('weaves')
1710
# deliberately not a WeaveFile as we want to build it up slowly.
1711
self.inv_weave = Weave('inventory')
1712
# holds in-memory weaves for all files
1713
self.text_weaves = {}
1714
self.bzrdir.transport.delete('branch-format')
1715
self.branch = self.bzrdir.open_branch()
1716
self._convert_working_inv()
1717
rev_history = self.branch.revision_history()
1718
# to_read is a stack holding the revisions we still need to process;
1719
# appending to it adds new highest-priority revisions
1720
self.known_revisions = set(rev_history)
1721
self.to_read = rev_history[-1:]
1723
rev_id = self.to_read.pop()
1724
if (rev_id not in self.revisions
1725
and rev_id not in self.absent_revisions):
1726
self._load_one_rev(rev_id)
1728
to_import = self._make_order()
1729
for i, rev_id in enumerate(to_import):
1730
self.pb.update('converting revision', i, len(to_import))
1731
self._convert_one_rev(rev_id)
1733
self._write_all_weaves()
1734
self._write_all_revs()
1735
self.pb.note('upgraded to weaves:')
1736
self.pb.note(' %6d revisions and inventories', len(self.revisions))
1737
self.pb.note(' %6d revisions not present', len(self.absent_revisions))
1738
self.pb.note(' %6d texts', self.text_count)
1739
self._cleanup_spare_files_after_format4()
1740
self.branch.control_files.put_utf8('branch-format', BzrDirFormat5().get_format_string())
1742
def _cleanup_spare_files_after_format4(self):
1743
# FIXME working tree upgrade foo.
1744
for n in 'merged-patches', 'pending-merged-patches':
1746
## assert os.path.getsize(p) == 0
1747
self.bzrdir.transport.delete(n)
1748
except errors.NoSuchFile:
1750
self.bzrdir.transport.delete_tree('inventory-store')
1751
self.bzrdir.transport.delete_tree('text-store')
1753
def _convert_working_inv(self):
1754
inv = xml4.serializer_v4.read_inventory(
1755
self.branch.control_files.get('inventory'))
1756
new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
1757
# FIXME inventory is a working tree change.
1758
self.branch.control_files.put('inventory', StringIO(new_inv_xml))
1760
def _write_all_weaves(self):
1761
controlweaves = WeaveStore(self.bzrdir.transport, prefixed=False)
1762
weave_transport = self.bzrdir.transport.clone('weaves')
1763
weaves = WeaveStore(weave_transport, prefixed=False)
1764
transaction = WriteTransaction()
1768
for file_id, file_weave in self.text_weaves.items():
1769
self.pb.update('writing weave', i, len(self.text_weaves))
1770
weaves._put_weave(file_id, file_weave, transaction)
1772
self.pb.update('inventory', 0, 1)
1773
controlweaves._put_weave('inventory', self.inv_weave, transaction)
1774
self.pb.update('inventory', 1, 1)
1778
def _write_all_revs(self):
1779
"""Write all revisions out in new form."""
1780
self.bzrdir.transport.delete_tree('revision-store')
1781
self.bzrdir.transport.mkdir('revision-store')
1782
revision_transport = self.bzrdir.transport.clone('revision-store')
1784
_revision_store = TextRevisionStore(TextStore(revision_transport,
1788
transaction = WriteTransaction()
1789
for i, rev_id in enumerate(self.converted_revs):
1790
self.pb.update('write revision', i, len(self.converted_revs))
1791
_revision_store.add_revision(self.revisions[rev_id], transaction)
1795
def _load_one_rev(self, rev_id):
1796
"""Load a revision object into memory.
1798
Any parents not either loaded or abandoned get queued to be
1800
self.pb.update('loading revision',
1801
len(self.revisions),
1802
len(self.known_revisions))
1803
if not self.branch.repository.has_revision(rev_id):
1805
self.pb.note('revision {%s} not present in branch; '
1806
'will be converted as a ghost',
1808
self.absent_revisions.add(rev_id)
1810
rev = self.branch.repository._revision_store.get_revision(rev_id,
1811
self.branch.repository.get_transaction())
1812
for parent_id in rev.parent_ids:
1813
self.known_revisions.add(parent_id)
1814
self.to_read.append(parent_id)
1815
self.revisions[rev_id] = rev
1817
def _load_old_inventory(self, rev_id):
1818
assert rev_id not in self.converted_revs
1819
old_inv_xml = self.branch.repository.inventory_store.get(rev_id).read()
1820
inv = xml4.serializer_v4.read_inventory_from_string(old_inv_xml)
1821
inv.revision_id = rev_id
1822
rev = self.revisions[rev_id]
1823
if rev.inventory_sha1:
1824
assert rev.inventory_sha1 == sha_string(old_inv_xml), \
1825
'inventory sha mismatch for {%s}' % rev_id
1828
def _load_updated_inventory(self, rev_id):
1829
assert rev_id in self.converted_revs
1830
inv_xml = self.inv_weave.get_text(rev_id)
1831
inv = xml5.serializer_v5.read_inventory_from_string(inv_xml)
1834
def _convert_one_rev(self, rev_id):
1835
"""Convert revision and all referenced objects to new format."""
1836
rev = self.revisions[rev_id]
1837
inv = self._load_old_inventory(rev_id)
1838
present_parents = [p for p in rev.parent_ids
1839
if p not in self.absent_revisions]
1840
self._convert_revision_contents(rev, inv, present_parents)
1841
self._store_new_weave(rev, inv, present_parents)
1842
self.converted_revs.add(rev_id)
1844
def _store_new_weave(self, rev, inv, present_parents):
1845
# the XML is now updated with text versions
1847
entries = inv.iter_entries()
1849
for path, ie in entries:
1850
assert getattr(ie, 'revision', None) is not None, \
1851
'no revision on {%s} in {%s}' % \
1852
(file_id, rev.revision_id)
1853
new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
1854
new_inv_sha1 = sha_string(new_inv_xml)
1855
self.inv_weave.add_lines(rev.revision_id,
1857
new_inv_xml.splitlines(True))
1858
rev.inventory_sha1 = new_inv_sha1
1860
def _convert_revision_contents(self, rev, inv, present_parents):
1861
"""Convert all the files within a revision.
1863
Also upgrade the inventory to refer to the text revision ids."""
1864
rev_id = rev.revision_id
1865
mutter('converting texts of revision {%s}',
1867
parent_invs = map(self._load_updated_inventory, present_parents)
1868
entries = inv.iter_entries()
1870
for path, ie in entries:
1871
self._convert_file_version(rev, ie, parent_invs)
1873
def _convert_file_version(self, rev, ie, parent_invs):
1874
"""Convert one version of one file.
1876
The file needs to be added into the weave if it is a merge
1877
of >=2 parents or if it's changed from its parent.
1879
file_id = ie.file_id
1880
rev_id = rev.revision_id
1881
w = self.text_weaves.get(file_id)
1884
self.text_weaves[file_id] = w
1885
text_changed = False
1886
previous_entries = ie.find_previous_heads(parent_invs,
1890
for old_revision in previous_entries:
1891
# if this fails, its a ghost ?
1892
assert old_revision in self.converted_revs, \
1893
"Revision {%s} not in converted_revs" % old_revision
1894
self.snapshot_ie(previous_entries, ie, w, rev_id)
1896
assert getattr(ie, 'revision', None) is not None
1898
def snapshot_ie(self, previous_revisions, ie, w, rev_id):
1899
# TODO: convert this logic, which is ~= snapshot to
1900
# a call to:. This needs the path figured out. rather than a work_tree
1901
# a v4 revision_tree can be given, or something that looks enough like
1902
# one to give the file content to the entry if it needs it.
1903
# and we need something that looks like a weave store for snapshot to
1905
#ie.snapshot(rev, PATH, previous_revisions, REVISION_TREE, InMemoryWeaveStore(self.text_weaves))
1906
if len(previous_revisions) == 1:
1907
previous_ie = previous_revisions.values()[0]
1908
if ie._unchanged(previous_ie):
1909
ie.revision = previous_ie.revision
1912
text = self.branch.repository.text_store.get(ie.text_id)
1913
file_lines = text.readlines()
1914
assert sha_strings(file_lines) == ie.text_sha1
1915
assert sum(map(len, file_lines)) == ie.text_size
1916
w.add_lines(rev_id, previous_revisions, file_lines)
1917
self.text_count += 1
1919
w.add_lines(rev_id, previous_revisions, [])
1920
ie.revision = rev_id
1922
def _make_order(self):
1923
"""Return a suitable order for importing revisions.
1925
The order must be such that an revision is imported after all
1926
its (present) parents.
1928
todo = set(self.revisions.keys())
1929
done = self.absent_revisions.copy()
1932
# scan through looking for a revision whose parents
1934
for rev_id in sorted(list(todo)):
1935
rev = self.revisions[rev_id]
1936
parent_ids = set(rev.parent_ids)
1937
if parent_ids.issubset(done):
1938
# can take this one now
1939
order.append(rev_id)
1945
class ConvertBzrDir5To6(Converter):
1946
"""Converts format 5 bzr dirs to format 6."""
1948
def convert(self, to_convert, pb):
1949
"""See Converter.convert()."""
1950
self.bzrdir = to_convert
1952
self.pb.note('starting upgrade from format 5 to 6')
1953
self._convert_to_prefixed()
1954
return BzrDir.open(self.bzrdir.root_transport.base)
1956
def _convert_to_prefixed(self):
1957
from bzrlib.store import TransportStore
1958
self.bzrdir.transport.delete('branch-format')
1959
for store_name in ["weaves", "revision-store"]:
1960
self.pb.note("adding prefixes to %s" % store_name)
1961
store_transport = self.bzrdir.transport.clone(store_name)
1962
store = TransportStore(store_transport, prefixed=True)
1963
for urlfilename in store_transport.list_dir('.'):
1964
filename = urlutils.unescape(urlfilename)
1965
if (filename.endswith(".weave") or
1966
filename.endswith(".gz") or
1967
filename.endswith(".sig")):
1968
file_id = os.path.splitext(filename)[0]
1971
prefix_dir = store.hash_prefix(file_id)
1972
# FIXME keep track of the dirs made RBC 20060121
1974
store_transport.move(filename, prefix_dir + '/' + filename)
1975
except errors.NoSuchFile: # catches missing dirs strangely enough
1976
store_transport.mkdir(prefix_dir)
1977
store_transport.move(filename, prefix_dir + '/' + filename)
1978
self.bzrdir._control_files.put_utf8('branch-format', BzrDirFormat6().get_format_string())
1981
class ConvertBzrDir6ToMeta(Converter):
1982
"""Converts format 6 bzr dirs to metadirs."""
1984
def convert(self, to_convert, pb):
1985
"""See Converter.convert()."""
1986
from bzrlib.repofmt.weaverepo import RepositoryFormat7
1987
from bzrlib.branch import BzrBranchFormat5
1988
self.bzrdir = to_convert
1991
self.total = 20 # the steps we know about
1992
self.garbage_inventories = []
1994
self.pb.note('starting upgrade from format 6 to metadir')
1995
self.bzrdir._control_files.put_utf8('branch-format', "Converting to format 6")
1996
# its faster to move specific files around than to open and use the apis...
1997
# first off, nuke ancestry.weave, it was never used.
1999
self.step('Removing ancestry.weave')
2000
self.bzrdir.transport.delete('ancestry.weave')
2001
except errors.NoSuchFile:
2003
# find out whats there
2004
self.step('Finding branch files')
2005
last_revision = self.bzrdir.open_branch().last_revision()
2006
bzrcontents = self.bzrdir.transport.list_dir('.')
2007
for name in bzrcontents:
2008
if name.startswith('basis-inventory.'):
2009
self.garbage_inventories.append(name)
2010
# create new directories for repository, working tree and branch
2011
self.dir_mode = self.bzrdir._control_files._dir_mode
2012
self.file_mode = self.bzrdir._control_files._file_mode
2013
repository_names = [('inventory.weave', True),
2014
('revision-store', True),
2016
self.step('Upgrading repository ')
2017
self.bzrdir.transport.mkdir('repository', mode=self.dir_mode)
2018
self.make_lock('repository')
2019
# we hard code the formats here because we are converting into
2020
# the meta format. The meta format upgrader can take this to a
2021
# future format within each component.
2022
self.put_format('repository', RepositoryFormat7())
2023
for entry in repository_names:
2024
self.move_entry('repository', entry)
2026
self.step('Upgrading branch ')
2027
self.bzrdir.transport.mkdir('branch', mode=self.dir_mode)
2028
self.make_lock('branch')
2029
self.put_format('branch', BzrBranchFormat5())
2030
branch_files = [('revision-history', True),
2031
('branch-name', True),
2033
for entry in branch_files:
2034
self.move_entry('branch', entry)
2036
checkout_files = [('pending-merges', True),
2037
('inventory', True),
2038
('stat-cache', False)]
2039
# If a mandatory checkout file is not present, the branch does not have
2040
# a functional checkout. Do not create a checkout in the converted
2042
for name, mandatory in checkout_files:
2043
if mandatory and name not in bzrcontents:
2044
has_checkout = False
2048
if not has_checkout:
2049
self.pb.note('No working tree.')
2050
# If some checkout files are there, we may as well get rid of them.
2051
for name, mandatory in checkout_files:
2052
if name in bzrcontents:
2053
self.bzrdir.transport.delete(name)
2055
from bzrlib.workingtree import WorkingTreeFormat3
2056
self.step('Upgrading working tree')
2057
self.bzrdir.transport.mkdir('checkout', mode=self.dir_mode)
2058
self.make_lock('checkout')
2060
'checkout', WorkingTreeFormat3())
2061
self.bzrdir.transport.delete_multi(
2062
self.garbage_inventories, self.pb)
2063
for entry in checkout_files:
2064
self.move_entry('checkout', entry)
2065
if last_revision is not None:
2066
self.bzrdir._control_files.put_utf8(
2067
'checkout/last-revision', last_revision)
2068
self.bzrdir._control_files.put_utf8(
2069
'branch-format', BzrDirMetaFormat1().get_format_string())
2070
return BzrDir.open(self.bzrdir.root_transport.base)
2072
def make_lock(self, name):
2073
"""Make a lock for the new control dir name."""
2074
self.step('Make %s lock' % name)
2075
ld = lockdir.LockDir(self.bzrdir.transport,
2077
file_modebits=self.file_mode,
2078
dir_modebits=self.dir_mode)
2081
def move_entry(self, new_dir, entry):
2082
"""Move then entry name into new_dir."""
2084
mandatory = entry[1]
2085
self.step('Moving %s' % name)
2087
self.bzrdir.transport.move(name, '%s/%s' % (new_dir, name))
2088
except errors.NoSuchFile:
2092
def put_format(self, dirname, format):
2093
self.bzrdir._control_files.put_utf8('%s/format' % dirname, format.get_format_string())
2096
class ConvertMetaToMeta(Converter):
1753
2097
"""Converts the components of metadirs."""
1755
2099
def __init__(self, target_format):
1762
2106
def convert(self, to_convert, pb):
1763
2107
"""See Converter.convert()."""
1764
self.controldir = to_convert
1765
with ui.ui_factory.nested_progress_bar() as self.pb:
1768
self.step('checking repository format')
1770
repo = self.controldir.open_repository()
1771
except errors.NoRepositoryPresent:
1774
repo_fmt = self.target_format.repository_format
1775
if not isinstance(repo._format, repo_fmt.__class__):
1776
from ..repository import CopyConverter
1777
ui.ui_factory.note(gettext('starting repository conversion'))
1778
if not repo_fmt.supports_overriding_transport:
1779
raise AssertionError(
1780
"Repository in metadir does not support "
1781
"overriding transport")
1782
converter = CopyConverter(self.target_format.repository_format)
1783
converter.convert(repo, pb)
1784
for branch in self.controldir.list_branches():
1785
# TODO: conversions of Branch and Tree should be done by
1786
# InterXFormat lookups/some sort of registry.
1787
# Avoid circular imports
1788
old = branch._format.__class__
1789
new = self.target_format.get_branch_format().__class__
1791
if (old == fullhistorybranch.BzrBranchFormat5
1792
and new in (_mod_bzrbranch.BzrBranchFormat6,
1793
_mod_bzrbranch.BzrBranchFormat7,
1794
_mod_bzrbranch.BzrBranchFormat8)):
1795
branch_converter = _mod_bzrbranch.Converter5to6()
1796
elif (old == _mod_bzrbranch.BzrBranchFormat6
1797
and new in (_mod_bzrbranch.BzrBranchFormat7,
1798
_mod_bzrbranch.BzrBranchFormat8)):
1799
branch_converter = _mod_bzrbranch.Converter6to7()
1800
elif (old == _mod_bzrbranch.BzrBranchFormat7
1801
and new is _mod_bzrbranch.BzrBranchFormat8):
1802
branch_converter = _mod_bzrbranch.Converter7to8()
1804
raise errors.BadConversionTarget("No converter", new,
1806
branch_converter.convert(branch)
1807
branch = self.controldir.open_branch()
1808
old = branch._format.__class__
1810
tree = self.controldir.open_workingtree(recommend_upgrade=False)
1811
except (errors.NoWorkingTree, errors.NotLocalUrl):
1814
# TODO: conversions of Branch and Tree should be done by
1815
# InterXFormat lookups
1816
if (isinstance(tree, workingtree_3.WorkingTree3)
1817
and not isinstance(tree, workingtree_4.DirStateWorkingTree)
1818
and isinstance(self.target_format.workingtree_format,
1819
workingtree_4.DirStateWorkingTreeFormat)):
1820
workingtree_4.Converter3to4().convert(tree)
1821
if (isinstance(tree, workingtree_4.DirStateWorkingTree)
1822
and not isinstance(tree, workingtree_4.WorkingTree5)
1823
and isinstance(self.target_format.workingtree_format,
1824
workingtree_4.WorkingTreeFormat5)):
1825
workingtree_4.Converter4to5().convert(tree)
1826
if (isinstance(tree, workingtree_4.DirStateWorkingTree)
1827
and not isinstance(tree, workingtree_4.WorkingTree6)
1828
and isinstance(self.target_format.workingtree_format,
1829
workingtree_4.WorkingTreeFormat6)):
1830
workingtree_4.Converter4or5to6().convert(tree)
2108
self.bzrdir = to_convert
2112
self.step('checking repository format')
2114
repo = self.bzrdir.open_repository()
2115
except errors.NoRepositoryPresent:
2118
if not isinstance(repo._format, self.target_format.repository_format.__class__):
2119
from bzrlib.repository import CopyConverter
2120
self.pb.note('starting repository conversion')
2121
converter = CopyConverter(self.target_format.repository_format)
2122
converter.convert(repo, pb)
2124
branch = self.bzrdir.open_branch()
2125
except errors.NotBranchError:
2128
# TODO: conversions of Branch and Tree should be done by
2129
# InterXFormat lookups
2130
# Avoid circular imports
2131
from bzrlib import branch as _mod_branch
2132
if (branch._format.__class__ is _mod_branch.BzrBranchFormat5 and
2133
self.target_format.get_branch_format().__class__ is
2134
_mod_branch.BzrBranchFormat6):
2135
branch_converter = _mod_branch.Converter5to6()
2136
branch_converter.convert(branch)
2138
tree = self.bzrdir.open_workingtree(recommend_upgrade=False)
2139
except (errors.NoWorkingTree, errors.NotLocalUrl):
2142
# TODO: conversions of Branch and Tree should be done by
2143
# InterXFormat lookups
2144
if (isinstance(tree, workingtree.WorkingTree3) and
2145
not isinstance(tree, workingtree_4.WorkingTree4) and
2146
isinstance(self.target_format.workingtree_format,
2147
workingtree_4.WorkingTreeFormat4)):
2148
workingtree_4.Converter3to4().convert(tree)
1831
2149
return to_convert
1834
class ConvertMetaToColo(controldir.Converter):
1835
"""Add colocated branch support."""
1837
def __init__(self, target_format):
1838
"""Create a converter.that upgrades a metadir to the colo format.
1840
:param target_format: The final metadir format that is desired.
1842
self.target_format = target_format
1844
def convert(self, to_convert, pb):
1845
"""See Converter.convert()."""
1846
to_convert.transport.put_bytes('branch-format',
1847
self.target_format.as_string())
1848
return BzrDir.open_from_transport(to_convert.root_transport)
1851
class ConvertMetaToColo(controldir.Converter):
1852
"""Convert a 'development-colo' bzrdir to a '2a' bzrdir."""
1854
def __init__(self, target_format):
1855
"""Create a converter that converts a 'development-colo' metadir
1858
:param target_format: The final metadir format that is desired.
1860
self.target_format = target_format
1862
def convert(self, to_convert, pb):
1863
"""See Converter.convert()."""
1864
to_convert.transport.put_bytes('branch-format',
1865
self.target_format.as_string())
1866
return BzrDir.open_from_transport(to_convert.root_transport)
1869
class CreateRepository(controldir.RepositoryAcquisitionPolicy):
1870
"""A policy of creating a new repository"""
1872
def __init__(self, controldir, stack_on=None, stack_on_pwd=None,
1873
require_stacking=False):
1876
:param controldir: The controldir to create the repository on.
1877
:param stack_on: A location to stack on
1878
:param stack_on_pwd: If stack_on is relative, the location it is
1881
super(CreateRepository, self).__init__(
1882
stack_on, stack_on_pwd, require_stacking)
1883
self._controldir = controldir
1885
def acquire_repository(self, make_working_trees=None, shared=False,
1886
possible_transports=None):
1887
"""Implementation of RepositoryAcquisitionPolicy.acquire_repository
1889
Creates the desired repository in the controldir we already have.
1891
if possible_transports is None:
1892
possible_transports = []
1894
possible_transports = list(possible_transports)
1895
possible_transports.append(self._controldir.root_transport)
1896
stack_on = self._get_full_stack_on()
1898
format = self._controldir._format
1899
format.require_stacking(stack_on=stack_on,
1900
possible_transports=possible_transports)
1901
if not self._require_stacking:
1902
# We have picked up automatic stacking somewhere.
1903
note(gettext('Using default stacking branch {0} at {1}').format(
1904
self._stack_on, self._stack_on_pwd))
1905
repository = self._controldir.create_repository(shared=shared)
1906
self._add_fallback(repository,
1907
possible_transports=possible_transports)
1908
if make_working_trees is not None:
1909
repository.set_make_working_trees(make_working_trees)
1910
return repository, True
1913
class UseExistingRepository(controldir.RepositoryAcquisitionPolicy):
1914
"""A policy of reusing an existing repository"""
1916
def __init__(self, repository, stack_on=None, stack_on_pwd=None,
1917
require_stacking=False):
1920
:param repository: The repository to use.
1921
:param stack_on: A location to stack on
1922
:param stack_on_pwd: If stack_on is relative, the location it is
1925
super(UseExistingRepository, self).__init__(
1926
stack_on, stack_on_pwd, require_stacking)
1927
self._repository = repository
1929
def acquire_repository(self, make_working_trees=None, shared=False,
1930
possible_transports=None):
1931
"""Implementation of RepositoryAcquisitionPolicy.acquire_repository
1933
Returns an existing repository to use.
1935
if possible_transports is None:
1936
possible_transports = []
1938
possible_transports = list(possible_transports)
1939
possible_transports.append(self._repository.controldir.transport)
1940
self._add_fallback(self._repository,
1941
possible_transports=possible_transports)
1942
return self._repository, False
1945
controldir.ControlDirFormat._default_format = BzrDirMetaFormat1()
2152
class BzrDirFormatInfo(object):
2154
def __init__(self, native, deprecated, hidden):
2155
self.deprecated = deprecated
2156
self.native = native
2157
self.hidden = hidden
2160
class BzrDirFormatRegistry(registry.Registry):
2161
"""Registry of user-selectable BzrDir subformats.
2163
Differs from BzrDirFormat._control_formats in that it provides sub-formats,
2164
e.g. BzrDirMeta1 with weave repository. Also, it's more user-oriented.
2167
def register_metadir(self, key,
2168
repository_format, help, native=True, deprecated=False,
2172
"""Register a metadir subformat.
2174
These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
2175
by the Repository format.
2177
:param repository_format: The fully-qualified repository format class
2179
:param branch_format: Fully-qualified branch format class name as
2181
:param tree_format: Fully-qualified tree format class name as
2184
# This should be expanded to support setting WorkingTree and Branch
2185
# formats, once BzrDirMetaFormat1 supports that.
2186
def _load(full_name):
2187
mod_name, factory_name = full_name.rsplit('.', 1)
2189
mod = __import__(mod_name, globals(), locals(),
2191
except ImportError, e:
2192
raise ImportError('failed to load %s: %s' % (full_name, e))
2194
factory = getattr(mod, factory_name)
2195
except AttributeError:
2196
raise AttributeError('no factory %s in module %r'
2201
bd = BzrDirMetaFormat1()
2202
if branch_format is not None:
2203
bd.set_branch_format(_load(branch_format))
2204
if tree_format is not None:
2205
bd.workingtree_format = _load(tree_format)
2206
if repository_format is not None:
2207
bd.repository_format = _load(repository_format)
2209
self.register(key, helper, help, native, deprecated, hidden)
2211
def register(self, key, factory, help, native=True, deprecated=False,
2213
"""Register a BzrDirFormat factory.
2215
The factory must be a callable that takes one parameter: the key.
2216
It must produce an instance of the BzrDirFormat when called.
2218
This function mainly exists to prevent the info object from being
2221
registry.Registry.register(self, key, factory, help,
2222
BzrDirFormatInfo(native, deprecated, hidden))
2224
def register_lazy(self, key, module_name, member_name, help, native=True,
2225
deprecated=False, hidden=False):
2226
registry.Registry.register_lazy(self, key, module_name, member_name,
2227
help, BzrDirFormatInfo(native, deprecated, hidden))
2229
def set_default(self, key):
2230
"""Set the 'default' key to be a clone of the supplied key.
2232
This method must be called once and only once.
2234
registry.Registry.register(self, 'default', self.get(key),
2235
self.get_help(key), info=self.get_info(key))
2237
def set_default_repository(self, key):
2238
"""Set the FormatRegistry default and Repository default.
2240
This is a transitional method while Repository.set_default_format
2243
if 'default' in self:
2244
self.remove('default')
2245
self.set_default(key)
2246
format = self.get('default')()
2247
assert isinstance(format, BzrDirMetaFormat1)
2249
def make_bzrdir(self, key):
2250
return self.get(key)()
2252
def help_topic(self, topic):
2253
output = textwrap.dedent("""\
2254
Bazaar directory formats
2255
------------------------
2257
These formats can be used for creating branches, working trees, and
2261
default_help = self.get_help('default')
2263
for key in self.keys():
2264
if key == 'default':
2266
help = self.get_help(key)
2267
if help == default_help:
2268
default_realkey = key
2270
help_pairs.append((key, help))
2272
def wrapped(key, help, info):
2274
help = '(native) ' + help
2275
return ' %s:\n%s\n\n' % (key,
2276
textwrap.fill(help, initial_indent=' ',
2277
subsequent_indent=' '))
2278
output += wrapped('%s/default' % default_realkey, default_help,
2279
self.get_info('default'))
2280
deprecated_pairs = []
2281
for key, help in help_pairs:
2282
info = self.get_info(key)
2285
elif info.deprecated:
2286
deprecated_pairs.append((key, help))
2288
output += wrapped(key, help, info)
2289
if len(deprecated_pairs) > 0:
2290
output += "Deprecated formats\n------------------\n\n"
2291
for key, help in deprecated_pairs:
2292
info = self.get_info(key)
2293
output += wrapped(key, help, info)
2298
format_registry = BzrDirFormatRegistry()
2299
format_registry.register('weave', BzrDirFormat6,
2300
'Pre-0.8 format. Slower than knit and does not'
2301
' support checkouts or shared repositories.',
2303
format_registry.register_metadir('knit',
2304
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
2305
'Format using knits. Recommended for interoperation with bzr <= 0.14.',
2306
branch_format='bzrlib.branch.BzrBranchFormat5',
2307
tree_format='bzrlib.workingtree.WorkingTreeFormat3')
2308
format_registry.register_metadir('metaweave',
2309
'bzrlib.repofmt.weaverepo.RepositoryFormat7',
2310
'Transitional format in 0.8. Slower than knit.',
2311
branch_format='bzrlib.branch.BzrBranchFormat5',
2312
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
2314
format_registry.register_metadir('dirstate',
2315
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
2316
help='New in 0.15: Fast local operations. Compatible with bzr 0.8 and '
2317
'above when accessed over the network.',
2318
branch_format='bzrlib.branch.BzrBranchFormat5',
2319
# this uses bzrlib.workingtree.WorkingTreeFormat4 because importing
2320
# directly from workingtree_4 triggers a circular import.
2321
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2323
format_registry.register_metadir('dirstate-tags',
2324
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
2325
help='New in 0.15: Fast local operations and improved scaling for '
2326
'network operations. Additionally adds support for tags.'
2327
' Incompatible with bzr < 0.15.',
2328
branch_format='bzrlib.branch.BzrBranchFormat6',
2329
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2331
format_registry.register_metadir('dirstate-with-subtree',
2332
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
2333
help='New in 0.15: Fast local operations and improved scaling for '
2334
'network operations. Additionally adds support for versioning nested '
2335
'bzr branches. Incompatible with bzr < 0.15.',
2336
branch_format='bzrlib.branch.BzrBranchFormat6',
2337
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2340
format_registry.set_default('dirstate')
added
removed
bzrlib/bzrdir.py
