1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
"""BzrDir logic. The BzrDir is the basic control directory used by bzr.
19
At format 7 this was split out into Branch, Repository and Checkout control
22
Note: This module has a lot of ``open`` functions/methods that return
23
references to in-memory objects. As a rule, there are no matching ``close``
24
methods. To free any associated resources, simply stop referencing the
28
# TODO: Move old formats into a plugin to make this file smaller.
33
from bzrlib.lazy_import import lazy_import
34
lazy_import(globals(), """
35
from stat import S_ISDIR
47
revision as _mod_revision,
57
from bzrlib.osutils import (
60
from bzrlib.smart.client import _SmartClient
61
from bzrlib.store.versioned import WeaveStore
62
from bzrlib.transactions import WriteTransaction
63
from bzrlib.transport import (
64
do_catching_redirections,
68
from bzrlib.weave import Weave
71
from bzrlib.trace import (
83
"""A .bzr control diretory.
85
BzrDir instances let you create or open any of the things that can be
86
found within .bzr - checkouts, branches and repositories.
89
the transport which this bzr dir is rooted at (i.e. file:///.../.bzr/)
91
a transport connected to the directory this bzr was opened from
92
(i.e. the parent directory holding the .bzr directory).
94
Everything in the bzrdir should have the same file permissions.
98
"""Invoke break_lock on the first object in the bzrdir.
100
If there is a tree, the tree is opened and break_lock() called.
101
Otherwise, branch is tried, and finally repository.
103
# XXX: This seems more like a UI function than something that really
104
# belongs in this class.
106
thing_to_unlock = self.open_workingtree()
107
except (errors.NotLocalUrl, errors.NoWorkingTree):
109
thing_to_unlock = self.open_branch()
110
except errors.NotBranchError:
112
thing_to_unlock = self.open_repository()
113
except errors.NoRepositoryPresent:
115
thing_to_unlock.break_lock()
117
def can_convert_format(self):
118
"""Return true if this bzrdir is one whose format we can convert from."""
121
def check_conversion_target(self, target_format):
122
target_repo_format = target_format.repository_format
123
source_repo_format = self._format.repository_format
124
source_repo_format.check_conversion_target(target_repo_format)
127
def _check_supported(format, allow_unsupported,
128
recommend_upgrade=True,
130
"""Give an error or warning on old formats.
132
:param format: may be any kind of format - workingtree, branch,
135
:param allow_unsupported: If true, allow opening
136
formats that are strongly deprecated, and which may
137
have limited functionality.
139
:param recommend_upgrade: If true (default), warn
140
the user through the ui object that they may wish
141
to upgrade the object.
143
# TODO: perhaps move this into a base Format class; it's not BzrDir
144
# specific. mbp 20070323
145
if not allow_unsupported and not format.is_supported():
146
# see open_downlevel to open legacy branches.
147
raise errors.UnsupportedFormatError(format=format)
148
if recommend_upgrade \
149
and getattr(format, 'upgrade_recommended', False):
150
ui.ui_factory.recommend_upgrade(
151
format.get_format_description(),
154
def clone(self, url, revision_id=None, force_new_repo=False,
155
preserve_stacking=False):
156
"""Clone this bzrdir and its contents to url verbatim.
158
:param url: The url create the clone at. If url's last component does
159
not exist, it will be created.
160
:param revision_id: The tip revision-id to use for any branch or
161
working tree. If not None, then the clone operation may tune
162
itself to download less data.
163
:param force_new_repo: Do not use a shared repository for the target
164
even if one is available.
165
:param preserve_stacking: When cloning a stacked branch, stack the
166
new branch on top of the other branch's stacked-on branch.
168
return self.clone_on_transport(get_transport(url),
169
revision_id=revision_id,
170
force_new_repo=force_new_repo,
171
preserve_stacking=preserve_stacking)
173
def clone_on_transport(self, transport, revision_id=None,
174
force_new_repo=False, preserve_stacking=False,
176
"""Clone this bzrdir and its contents to transport verbatim.
178
:param transport: The transport for the location to produce the clone
179
at. If the target directory does not exist, it will be created.
180
:param revision_id: The tip revision-id to use for any branch or
181
working tree. If not None, then the clone operation may tune
182
itself to download less data.
183
:param force_new_repo: Do not use a shared repository for the target,
184
even if one is available.
185
:param preserve_stacking: When cloning a stacked branch, stack the
186
new branch on top of the other branch's stacked-on branch.
188
transport.ensure_base()
189
require_stacking = (stacked_on is not None)
190
metadir = self.cloning_metadir(require_stacking)
191
result = metadir.initialize_on_transport(transport)
192
repository_policy = None
194
local_repo = self.find_repository()
195
except errors.NoRepositoryPresent:
198
local_branch = self.open_branch()
199
except errors.NotBranchError:
202
# enable fallbacks when branch is not a branch reference
203
if local_branch.repository.has_same_location(local_repo):
204
local_repo = local_branch.repository
205
if preserve_stacking:
207
stacked_on = local_branch.get_stacked_on_url()
208
except (errors.UnstackableBranchFormat,
209
errors.UnstackableRepositoryFormat,
214
# may need to copy content in
215
repository_policy = result.determine_repository_policy(
216
force_new_repo, stacked_on, self.root_transport.base,
217
require_stacking=require_stacking)
218
make_working_trees = local_repo.make_working_trees()
219
result_repo = repository_policy.acquire_repository(
220
make_working_trees, local_repo.is_shared())
221
if not require_stacking and repository_policy._require_stacking:
222
require_stacking = True
223
result._format.require_stacking()
224
result_repo.fetch(local_repo, revision_id=revision_id)
227
# 1 if there is a branch present
228
# make sure its content is available in the target repository
230
if local_branch is not None:
231
result_branch = local_branch.clone(result, revision_id=revision_id)
232
if repository_policy is not None:
233
repository_policy.configure_branch(result_branch)
234
if result_repo is None or result_repo.make_working_trees():
236
self.open_workingtree().clone(result)
237
except (errors.NoWorkingTree, errors.NotLocalUrl):
241
# TODO: This should be given a Transport, and should chdir up; otherwise
242
# this will open a new connection.
243
def _make_tail(self, url):
244
t = get_transport(url)
248
def create(cls, base, format=None, possible_transports=None):
249
"""Create a new BzrDir at the url 'base'.
251
:param format: If supplied, the format of branch to create. If not
252
supplied, the default is used.
253
:param possible_transports: If supplied, a list of transports that
254
can be reused to share a remote connection.
256
if cls is not BzrDir:
257
raise AssertionError("BzrDir.create always creates the default"
258
" format, not one of %r" % cls)
259
t = get_transport(base, possible_transports)
262
format = BzrDirFormat.get_default_format()
263
return format.initialize_on_transport(t)
266
def find_bzrdirs(transport, evaluate=None, list_current=None):
267
"""Find bzrdirs recursively from current location.
269
This is intended primarily as a building block for more sophisticated
270
functionality, like finding trees under a directory, or finding
271
branches that use a given repository.
272
:param evaluate: An optional callable that yields recurse, value,
273
where recurse controls whether this bzrdir is recursed into
274
and value is the value to yield. By default, all bzrdirs
275
are recursed into, and the return value is the bzrdir.
276
:param list_current: if supplied, use this function to list the current
277
directory, instead of Transport.list_dir
278
:return: a generator of found bzrdirs, or whatever evaluate returns.
280
if list_current is None:
281
def list_current(transport):
282
return transport.list_dir('')
284
def evaluate(bzrdir):
287
pending = [transport]
288
while len(pending) > 0:
289
current_transport = pending.pop()
292
bzrdir = BzrDir.open_from_transport(current_transport)
293
except errors.NotBranchError:
296
recurse, value = evaluate(bzrdir)
299
subdirs = list_current(current_transport)
300
except errors.NoSuchFile:
303
for subdir in sorted(subdirs, reverse=True):
304
pending.append(current_transport.clone(subdir))
307
def find_branches(transport):
308
"""Find all branches under a transport.
310
This will find all branches below the transport, including branches
311
inside other branches. Where possible, it will use
312
Repository.find_branches.
314
To list all the branches that use a particular Repository, see
315
Repository.find_branches
317
def evaluate(bzrdir):
319
repository = bzrdir.open_repository()
320
except errors.NoRepositoryPresent:
323
return False, (None, repository)
325
branch = bzrdir.open_branch()
326
except errors.NotBranchError:
327
return True, (None, None)
329
return True, (branch, None)
331
for branch, repo in BzrDir.find_bzrdirs(transport, evaluate=evaluate):
333
branches.extend(repo.find_branches())
334
if branch is not None:
335
branches.append(branch)
338
def destroy_repository(self):
339
"""Destroy the repository in this BzrDir"""
340
raise NotImplementedError(self.destroy_repository)
342
def create_branch(self):
343
"""Create a branch in this BzrDir.
345
The bzrdir's format will control what branch format is created.
346
For more control see BranchFormatXX.create(a_bzrdir).
348
raise NotImplementedError(self.create_branch)
350
def destroy_branch(self):
351
"""Destroy the branch in this BzrDir"""
352
raise NotImplementedError(self.destroy_branch)
355
def create_branch_and_repo(base, force_new_repo=False, format=None):
356
"""Create a new BzrDir, Branch and Repository at the url 'base'.
358
This will use the current default BzrDirFormat unless one is
359
specified, and use whatever
360
repository format that that uses via bzrdir.create_branch and
361
create_repository. If a shared repository is available that is used
364
The created Branch object is returned.
366
:param base: The URL to create the branch at.
367
:param force_new_repo: If True a new repository is always created.
368
:param format: If supplied, the format of branch to create. If not
369
supplied, the default is used.
371
bzrdir = BzrDir.create(base, format)
372
bzrdir._find_or_create_repository(force_new_repo)
373
return bzrdir.create_branch()
375
def determine_repository_policy(self, force_new_repo=False, stack_on=None,
376
stack_on_pwd=None, require_stacking=False):
377
"""Return an object representing a policy to use.
379
This controls whether a new repository is created, or a shared
380
repository used instead.
382
If stack_on is supplied, will not seek a containing shared repo.
384
:param force_new_repo: If True, require a new repository to be created.
385
:param stack_on: If supplied, the location to stack on. If not
386
supplied, a default_stack_on location may be used.
387
:param stack_on_pwd: If stack_on is relative, the location it is
390
def repository_policy(found_bzrdir):
393
config = found_bzrdir.get_config()
395
if config is not None:
396
stack_on = config.get_default_stack_on()
397
if stack_on is not None:
398
stack_on_pwd = found_bzrdir.root_transport.base
400
note('Using default stacking branch %s at %s', stack_on,
402
# does it have a repository ?
404
repository = found_bzrdir.open_repository()
405
except errors.NoRepositoryPresent:
408
if ((found_bzrdir.root_transport.base !=
409
self.root_transport.base) and not repository.is_shared()):
416
return UseExistingRepository(repository, stack_on,
417
stack_on_pwd, require_stacking=require_stacking), True
419
return CreateRepository(self, stack_on, stack_on_pwd,
420
require_stacking=require_stacking), True
422
if not force_new_repo:
424
policy = self._find_containing(repository_policy)
425
if policy is not None:
429
return UseExistingRepository(self.open_repository(),
430
stack_on, stack_on_pwd,
431
require_stacking=require_stacking)
432
except errors.NoRepositoryPresent:
434
return CreateRepository(self, stack_on, stack_on_pwd,
435
require_stacking=require_stacking)
437
def _find_or_create_repository(self, force_new_repo):
438
"""Create a new repository if needed, returning the repository."""
439
policy = self.determine_repository_policy(force_new_repo)
440
return policy.acquire_repository()
443
def create_branch_convenience(base, force_new_repo=False,
444
force_new_tree=None, format=None,
445
possible_transports=None):
446
"""Create a new BzrDir, Branch and Repository at the url 'base'.
448
This is a convenience function - it will use an existing repository
449
if possible, can be told explicitly whether to create a working tree or
452
This will use the current default BzrDirFormat unless one is
453
specified, and use whatever
454
repository format that that uses via bzrdir.create_branch and
455
create_repository. If a shared repository is available that is used
456
preferentially. Whatever repository is used, its tree creation policy
459
The created Branch object is returned.
460
If a working tree cannot be made due to base not being a file:// url,
461
no error is raised unless force_new_tree is True, in which case no
462
data is created on disk and NotLocalUrl is raised.
464
:param base: The URL to create the branch at.
465
:param force_new_repo: If True a new repository is always created.
466
:param force_new_tree: If True or False force creation of a tree or
467
prevent such creation respectively.
468
:param format: Override for the bzrdir format to create.
469
:param possible_transports: An optional reusable transports list.
472
# check for non local urls
473
t = get_transport(base, possible_transports)
474
if not isinstance(t, local.LocalTransport):
475
raise errors.NotLocalUrl(base)
476
bzrdir = BzrDir.create(base, format, possible_transports)
477
repo = bzrdir._find_or_create_repository(force_new_repo)
478
result = bzrdir.create_branch()
479
if force_new_tree or (repo.make_working_trees() and
480
force_new_tree is None):
482
bzrdir.create_workingtree()
483
except errors.NotLocalUrl:
488
def create_standalone_workingtree(base, format=None):
489
"""Create a new BzrDir, WorkingTree, Branch and Repository at 'base'.
491
'base' must be a local path or a file:// url.
493
This will use the current default BzrDirFormat unless one is
494
specified, and use whatever
495
repository format that that uses for bzrdirformat.create_workingtree,
496
create_branch and create_repository.
498
:param format: Override for the bzrdir format to create.
499
:return: The WorkingTree object.
501
t = get_transport(base)
502
if not isinstance(t, local.LocalTransport):
503
raise errors.NotLocalUrl(base)
504
bzrdir = BzrDir.create_branch_and_repo(base,
506
format=format).bzrdir
507
return bzrdir.create_workingtree()
509
def create_workingtree(self, revision_id=None, from_branch=None,
510
accelerator_tree=None, hardlink=False):
511
"""Create a working tree at this BzrDir.
513
:param revision_id: create it as of this revision id.
514
:param from_branch: override bzrdir branch (for lightweight checkouts)
515
:param accelerator_tree: A tree which can be used for retrieving file
516
contents more quickly than the revision tree, i.e. a workingtree.
517
The revision tree will be used for cases where accelerator_tree's
518
content is different.
520
raise NotImplementedError(self.create_workingtree)
522
def backup_bzrdir(self):
523
"""Backup this bzr control directory.
525
:return: Tuple with old path name and new path name
527
pb = ui.ui_factory.nested_progress_bar()
529
# FIXME: bug 300001 -- the backup fails if the backup directory
530
# already exists, but it should instead either remove it or make
531
# a new backup directory.
533
# FIXME: bug 262450 -- the backup directory should have the same
534
# permissions as the .bzr directory (probably a bug in copy_tree)
535
old_path = self.root_transport.abspath('.bzr')
536
new_path = self.root_transport.abspath('backup.bzr')
537
pb.note('making backup of %s' % (old_path,))
538
pb.note(' to %s' % (new_path,))
539
self.root_transport.copy_tree('.bzr', 'backup.bzr')
540
return (old_path, new_path)
544
def retire_bzrdir(self, limit=10000):
545
"""Permanently disable the bzrdir.
547
This is done by renaming it to give the user some ability to recover
548
if there was a problem.
550
This will have horrible consequences if anyone has anything locked or
552
:param limit: number of times to retry
557
to_path = '.bzr.retired.%d' % i
558
self.root_transport.rename('.bzr', to_path)
559
note("renamed %s to %s"
560
% (self.root_transport.abspath('.bzr'), to_path))
562
except (errors.TransportError, IOError, errors.PathError):
569
def destroy_workingtree(self):
570
"""Destroy the working tree at this BzrDir.
572
Formats that do not support this may raise UnsupportedOperation.
574
raise NotImplementedError(self.destroy_workingtree)
576
def destroy_workingtree_metadata(self):
577
"""Destroy the control files for the working tree at this BzrDir.
579
The contents of working tree files are not affected.
580
Formats that do not support this may raise UnsupportedOperation.
582
raise NotImplementedError(self.destroy_workingtree_metadata)
584
def _find_containing(self, evaluate):
585
"""Find something in a containing control directory.
587
This method will scan containing control dirs, until it finds what
588
it is looking for, decides that it will never find it, or runs out
589
of containing control directories to check.
591
It is used to implement find_repository and
592
determine_repository_policy.
594
:param evaluate: A function returning (value, stop). If stop is True,
595
the value will be returned.
599
result, stop = evaluate(found_bzrdir)
602
next_transport = found_bzrdir.root_transport.clone('..')
603
if (found_bzrdir.root_transport.base == next_transport.base):
604
# top of the file system
606
# find the next containing bzrdir
608
found_bzrdir = BzrDir.open_containing_from_transport(
610
except errors.NotBranchError:
613
def find_repository(self):
614
"""Find the repository that should be used.
616
This does not require a branch as we use it to find the repo for
617
new branches as well as to hook existing branches up to their
620
def usable_repository(found_bzrdir):
621
# does it have a repository ?
623
repository = found_bzrdir.open_repository()
624
except errors.NoRepositoryPresent:
626
if found_bzrdir.root_transport.base == self.root_transport.base:
627
return repository, True
628
elif repository.is_shared():
629
return repository, True
633
found_repo = self._find_containing(usable_repository)
634
if found_repo is None:
635
raise errors.NoRepositoryPresent(self)
638
def get_branch_reference(self):
639
"""Return the referenced URL for the branch in this bzrdir.
641
:raises NotBranchError: If there is no Branch.
642
:return: The URL the branch in this bzrdir references if it is a
643
reference branch, or None for regular branches.
647
def get_branch_transport(self, branch_format):
648
"""Get the transport for use by branch format in this BzrDir.
650
Note that bzr dirs that do not support format strings will raise
651
IncompatibleFormat if the branch format they are given has
652
a format string, and vice versa.
654
If branch_format is None, the transport is returned with no
655
checking. If it is not None, then the returned transport is
656
guaranteed to point to an existing directory ready for use.
658
raise NotImplementedError(self.get_branch_transport)
660
def _find_creation_modes(self):
661
"""Determine the appropriate modes for files and directories.
663
They're always set to be consistent with the base directory,
664
assuming that this transport allows setting modes.
666
# TODO: Do we need or want an option (maybe a config setting) to turn
667
# this off or override it for particular locations? -- mbp 20080512
668
if self._mode_check_done:
670
self._mode_check_done = True
672
st = self.transport.stat('.')
673
except errors.TransportNotPossible:
674
self._dir_mode = None
675
self._file_mode = None
677
# Check the directory mode, but also make sure the created
678
# directories and files are read-write for this user. This is
679
# mostly a workaround for filesystems which lie about being able to
680
# write to a directory (cygwin & win32)
681
if (st.st_mode & 07777 == 00000):
682
# FTP allows stat but does not return dir/file modes
683
self._dir_mode = None
684
self._file_mode = None
686
self._dir_mode = (st.st_mode & 07777) | 00700
687
# Remove the sticky and execute bits for files
688
self._file_mode = self._dir_mode & ~07111
690
def _get_file_mode(self):
691
"""Return Unix mode for newly created files, or None.
693
if not self._mode_check_done:
694
self._find_creation_modes()
695
return self._file_mode
697
def _get_dir_mode(self):
698
"""Return Unix mode for newly created directories, or None.
700
if not self._mode_check_done:
701
self._find_creation_modes()
702
return self._dir_mode
704
def get_repository_transport(self, repository_format):
705
"""Get the transport for use by repository format in this BzrDir.
707
Note that bzr dirs that do not support format strings will raise
708
IncompatibleFormat if the repository format they are given has
709
a format string, and vice versa.
711
If repository_format is None, the transport is returned with no
712
checking. If it is not None, then the returned transport is
713
guaranteed to point to an existing directory ready for use.
715
raise NotImplementedError(self.get_repository_transport)
717
def get_workingtree_transport(self, tree_format):
718
"""Get the transport for use by workingtree format in this BzrDir.
720
Note that bzr dirs that do not support format strings will raise
721
IncompatibleFormat if the workingtree format they are given has a
722
format string, and vice versa.
724
If workingtree_format is None, the transport is returned with no
725
checking. If it is not None, then the returned transport is
726
guaranteed to point to an existing directory ready for use.
728
raise NotImplementedError(self.get_workingtree_transport)
730
def get_config(self):
731
if getattr(self, '_get_config', None) is None:
733
return self._get_config()
735
def __init__(self, _transport, _format):
736
"""Initialize a Bzr control dir object.
738
Only really common logic should reside here, concrete classes should be
739
made with varying behaviours.
741
:param _format: the format that is creating this BzrDir instance.
742
:param _transport: the transport this dir is based at.
744
self._format = _format
745
self.transport = _transport.clone('.bzr')
746
self.root_transport = _transport
747
self._mode_check_done = False
749
def is_control_filename(self, filename):
750
"""True if filename is the name of a path which is reserved for bzrdir's.
752
:param filename: A filename within the root transport of this bzrdir.
754
This is true IF and ONLY IF the filename is part of the namespace reserved
755
for bzr control dirs. Currently this is the '.bzr' directory in the root
756
of the root_transport. it is expected that plugins will need to extend
757
this in the future - for instance to make bzr talk with svn working
760
# this might be better on the BzrDirFormat class because it refers to
761
# all the possible bzrdir disk formats.
762
# This method is tested via the workingtree is_control_filename tests-
763
# it was extracted from WorkingTree.is_control_filename. If the method's
764
# contract is extended beyond the current trivial implementation, please
765
# add new tests for it to the appropriate place.
766
return filename == '.bzr' or filename.startswith('.bzr/')
768
def needs_format_conversion(self, format=None):
769
"""Return true if this bzrdir needs convert_format run on it.
771
For instance, if the repository format is out of date but the
772
branch and working tree are not, this should return True.
774
:param format: Optional parameter indicating a specific desired
775
format we plan to arrive at.
777
raise NotImplementedError(self.needs_format_conversion)
780
def open_unsupported(base):
781
"""Open a branch which is not supported."""
782
return BzrDir.open(base, _unsupported=True)
785
def open(base, _unsupported=False, possible_transports=None):
786
"""Open an existing bzrdir, rooted at 'base' (url).
788
:param _unsupported: a private parameter to the BzrDir class.
790
t = get_transport(base, possible_transports=possible_transports)
791
return BzrDir.open_from_transport(t, _unsupported=_unsupported)
794
def open_from_transport(transport, _unsupported=False,
795
_server_formats=True):
796
"""Open a bzrdir within a particular directory.
798
:param transport: Transport containing the bzrdir.
799
:param _unsupported: private.
801
# Keep initial base since 'transport' may be modified while following
803
base = transport.base
804
def find_format(transport):
805
return transport, BzrDirFormat.find_format(
806
transport, _server_formats=_server_formats)
808
def redirected(transport, e, redirection_notice):
809
redirected_transport = transport._redirected_to(e.source, e.target)
810
if redirected_transport is None:
811
raise errors.NotBranchError(base)
812
note('%s is%s redirected to %s',
813
transport.base, e.permanently, redirected_transport.base)
814
return redirected_transport
817
transport, format = do_catching_redirections(find_format,
820
except errors.TooManyRedirections:
821
raise errors.NotBranchError(base)
823
BzrDir._check_supported(format, _unsupported)
824
return format.open(transport, _found=True)
826
def open_branch(self, unsupported=False):
827
"""Open the branch object at this BzrDir if one is present.
829
If unsupported is True, then no longer supported branch formats can
832
TODO: static convenience version of this?
834
raise NotImplementedError(self.open_branch)
837
def open_containing(url, possible_transports=None):
838
"""Open an existing branch which contains url.
840
:param url: url to search from.
841
See open_containing_from_transport for more detail.
843
transport = get_transport(url, possible_transports)
844
return BzrDir.open_containing_from_transport(transport)
847
def open_containing_from_transport(a_transport):
848
"""Open an existing branch which contains a_transport.base.
850
This probes for a branch at a_transport, and searches upwards from there.
852
Basically we keep looking up until we find the control directory or
853
run into the root. If there isn't one, raises NotBranchError.
854
If there is one and it is either an unrecognised format or an unsupported
855
format, UnknownFormatError or UnsupportedFormatError are raised.
856
If there is one, it is returned, along with the unused portion of url.
858
:return: The BzrDir that contains the path, and a Unicode path
859
for the rest of the URL.
861
# this gets the normalised url back. I.e. '.' -> the full path.
862
url = a_transport.base
865
result = BzrDir.open_from_transport(a_transport)
866
return result, urlutils.unescape(a_transport.relpath(url))
867
except errors.NotBranchError, e:
870
new_t = a_transport.clone('..')
871
except errors.InvalidURLJoin:
872
# reached the root, whatever that may be
873
raise errors.NotBranchError(path=url)
874
if new_t.base == a_transport.base:
875
# reached the root, whatever that may be
876
raise errors.NotBranchError(path=url)
879
def _get_tree_branch(self):
880
"""Return the branch and tree, if any, for this bzrdir.
882
Return None for tree if not present or inaccessible.
883
Raise NotBranchError if no branch is present.
884
:return: (tree, branch)
887
tree = self.open_workingtree()
888
except (errors.NoWorkingTree, errors.NotLocalUrl):
890
branch = self.open_branch()
896
def open_tree_or_branch(klass, location):
897
"""Return the branch and working tree at a location.
899
If there is no tree at the location, tree will be None.
900
If there is no branch at the location, an exception will be
902
:return: (tree, branch)
904
bzrdir = klass.open(location)
905
return bzrdir._get_tree_branch()
908
def open_containing_tree_or_branch(klass, location):
909
"""Return the branch and working tree contained by a location.
911
Returns (tree, branch, relpath).
912
If there is no tree at containing the location, tree will be None.
913
If there is no branch containing the location, an exception will be
915
relpath is the portion of the path that is contained by the branch.
917
bzrdir, relpath = klass.open_containing(location)
918
tree, branch = bzrdir._get_tree_branch()
919
return tree, branch, relpath
922
def open_containing_tree_branch_or_repository(klass, location):
923
"""Return the working tree, branch and repo contained by a location.
925
Returns (tree, branch, repository, relpath).
926
If there is no tree containing the location, tree will be None.
927
If there is no branch containing the location, branch will be None.
928
If there is no repository containing the location, repository will be
930
relpath is the portion of the path that is contained by the innermost
933
If no tree, branch or repository is found, a NotBranchError is raised.
935
bzrdir, relpath = klass.open_containing(location)
937
tree, branch = bzrdir._get_tree_branch()
938
except errors.NotBranchError:
940
repo = bzrdir.find_repository()
941
return None, None, repo, relpath
942
except (errors.NoRepositoryPresent):
943
raise errors.NotBranchError(location)
944
return tree, branch, branch.repository, relpath
946
def open_repository(self, _unsupported=False):
947
"""Open the repository object at this BzrDir if one is present.
949
This will not follow the Branch object pointer - it's strictly a direct
950
open facility. Most client code should use open_branch().repository to
953
:param _unsupported: a private parameter, not part of the api.
954
TODO: static convenience version of this?
956
raise NotImplementedError(self.open_repository)
958
def open_workingtree(self, _unsupported=False,
959
recommend_upgrade=True, from_branch=None):
960
"""Open the workingtree object at this BzrDir if one is present.
962
:param recommend_upgrade: Optional keyword parameter, when True (the
963
default), emit through the ui module a recommendation that the user
964
upgrade the working tree when the workingtree being opened is old
965
(but still fully supported).
966
:param from_branch: override bzrdir branch (for lightweight checkouts)
968
raise NotImplementedError(self.open_workingtree)
970
def has_branch(self):
971
"""Tell if this bzrdir contains a branch.
973
Note: if you're going to open the branch, you should just go ahead
974
and try, and not ask permission first. (This method just opens the
975
branch and discards it, and that's somewhat expensive.)
980
except errors.NotBranchError:
983
def has_workingtree(self):
984
"""Tell if this bzrdir contains a working tree.
986
This will still raise an exception if the bzrdir has a workingtree that
987
is remote & inaccessible.
989
Note: if you're going to open the working tree, you should just go ahead
990
and try, and not ask permission first. (This method just opens the
991
workingtree and discards it, and that's somewhat expensive.)
994
self.open_workingtree(recommend_upgrade=False)
996
except errors.NoWorkingTree:
999
def _cloning_metadir(self):
1000
"""Produce a metadir suitable for cloning with.
1002
:returns: (destination_bzrdir_format, source_repository)
1004
result_format = self._format.__class__()
1007
branch = self.open_branch()
1008
source_repository = branch.repository
1009
result_format._branch_format = branch._format
1010
except errors.NotBranchError:
1011
source_branch = None
1012
source_repository = self.open_repository()
1013
except errors.NoRepositoryPresent:
1014
source_repository = None
1016
# XXX TODO: This isinstance is here because we have not implemented
1017
# the fix recommended in bug # 103195 - to delegate this choice the
1018
# repository itself.
1019
repo_format = source_repository._format
1020
if isinstance(repo_format, remote.RemoteRepositoryFormat):
1021
source_repository._ensure_real()
1022
repo_format = source_repository._real_repository._format
1023
result_format.repository_format = repo_format
1025
# TODO: Couldn't we just probe for the format in these cases,
1026
# rather than opening the whole tree? It would be a little
1027
# faster. mbp 20070401
1028
tree = self.open_workingtree(recommend_upgrade=False)
1029
except (errors.NoWorkingTree, errors.NotLocalUrl):
1030
result_format.workingtree_format = None
1032
result_format.workingtree_format = tree._format.__class__()
1033
return result_format, source_repository
1035
def cloning_metadir(self, require_stacking=False):
1036
"""Produce a metadir suitable for cloning or sprouting with.
1038
These operations may produce workingtrees (yes, even though they're
1039
"cloning" something that doesn't have a tree), so a viable workingtree
1040
format must be selected.
1042
:require_stacking: If True, non-stackable formats will be upgraded
1043
to similar stackable formats.
1044
:returns: a BzrDirFormat with all component formats either set
1045
appropriately or set to None if that component should not be
1048
format, repository = self._cloning_metadir()
1049
if format._workingtree_format is None:
1050
if repository is None:
1052
tree_format = repository._format._matchingbzrdir.workingtree_format
1053
format.workingtree_format = tree_format.__class__()
1054
if require_stacking:
1055
format.require_stacking()
1058
def checkout_metadir(self):
1059
return self.cloning_metadir()
1061
def sprout(self, url, revision_id=None, force_new_repo=False,
1062
recurse='down', possible_transports=None,
1063
accelerator_tree=None, hardlink=False, stacked=False,
1064
source_branch=None, create_tree_if_local=True):
1065
"""Create a copy of this bzrdir prepared for use as a new line of
1068
If url's last component does not exist, it will be created.
1070
Attributes related to the identity of the source branch like
1071
branch nickname will be cleaned, a working tree is created
1072
whether one existed before or not; and a local branch is always
1075
if revision_id is not None, then the clone operation may tune
1076
itself to download less data.
1077
:param accelerator_tree: A tree which can be used for retrieving file
1078
contents more quickly than the revision tree, i.e. a workingtree.
1079
The revision tree will be used for cases where accelerator_tree's
1080
content is different.
1081
:param hardlink: If true, hard-link files from accelerator_tree,
1083
:param stacked: If true, create a stacked branch referring to the
1084
location of this control directory.
1085
:param create_tree_if_local: If true, a working-tree will be created
1086
when working locally.
1088
target_transport = get_transport(url, possible_transports)
1089
target_transport.ensure_base()
1090
cloning_format = self.cloning_metadir(stacked)
1091
# Create/update the result branch
1092
result = cloning_format.initialize_on_transport(target_transport)
1093
# if a stacked branch wasn't requested, we don't create one
1094
# even if the origin was stacked
1095
stacked_branch_url = None
1096
if source_branch is not None:
1098
stacked_branch_url = self.root_transport.base
1099
source_repository = source_branch.repository
1102
source_branch = self.open_branch()
1103
source_repository = source_branch.repository
1105
stacked_branch_url = self.root_transport.base
1106
except errors.NotBranchError:
1107
source_branch = None
1109
source_repository = self.open_repository()
1110
except errors.NoRepositoryPresent:
1111
source_repository = None
1112
repository_policy = result.determine_repository_policy(
1113
force_new_repo, stacked_branch_url, require_stacking=stacked)
1114
result_repo = repository_policy.acquire_repository()
1115
if source_repository is not None:
1116
# Fetch while stacked to prevent unstacked fetch from
1118
result_repo.fetch(source_repository, revision_id=revision_id)
1120
if source_branch is None:
1121
# this is for sprouting a bzrdir without a branch; is that
1123
# Not especially, but it's part of the contract.
1124
result_branch = result.create_branch()
1126
# Force NULL revision to avoid using repository before stacking
1128
result_branch = source_branch.sprout(
1129
result, revision_id=_mod_revision.NULL_REVISION)
1130
parent_location = result_branch.get_parent()
1131
mutter("created new branch %r" % (result_branch,))
1132
repository_policy.configure_branch(result_branch)
1133
if source_branch is not None:
1134
source_branch.copy_content_into(result_branch, revision_id)
1135
# Override copy_content_into
1136
result_branch.set_parent(parent_location)
1138
# Create/update the result working tree
1139
if (create_tree_if_local and
1140
isinstance(target_transport, local.LocalTransport) and
1141
(result_repo is None or result_repo.make_working_trees())):
1142
wt = result.create_workingtree(accelerator_tree=accelerator_tree,
1146
if wt.path2id('') is None:
1148
wt.set_root_id(self.open_workingtree.get_root_id())
1149
except errors.NoWorkingTree:
1155
if recurse == 'down':
1157
basis = wt.basis_tree()
1159
subtrees = basis.iter_references()
1160
elif result_branch is not None:
1161
basis = result_branch.basis_tree()
1163
subtrees = basis.iter_references()
1164
elif source_branch is not None:
1165
basis = source_branch.basis_tree()
1167
subtrees = basis.iter_references()
1172
for path, file_id in subtrees:
1173
target = urlutils.join(url, urlutils.escape(path))
1174
sublocation = source_branch.reference_parent(file_id, path)
1175
sublocation.bzrdir.sprout(target,
1176
basis.get_reference_revision(file_id, path),
1177
force_new_repo=force_new_repo, recurse=recurse,
1180
if basis is not None:
1185
class BzrDirPreSplitOut(BzrDir):
1186
"""A common class for the all-in-one formats."""
1188
def __init__(self, _transport, _format):
1189
"""See BzrDir.__init__."""
1190
super(BzrDirPreSplitOut, self).__init__(_transport, _format)
1191
self._control_files = lockable_files.LockableFiles(
1192
self.get_branch_transport(None),
1193
self._format._lock_file_name,
1194
self._format._lock_class)
1196
def break_lock(self):
1197
"""Pre-splitout bzrdirs do not suffer from stale locks."""
1198
raise NotImplementedError(self.break_lock)
1200
def cloning_metadir(self, require_stacking=False):
1201
"""Produce a metadir suitable for cloning with."""
1202
if require_stacking:
1203
return format_registry.make_bzrdir('1.6')
1204
return self._format.__class__()
1206
def clone(self, url, revision_id=None, force_new_repo=False,
1207
preserve_stacking=False):
1208
"""See BzrDir.clone().
1210
force_new_repo has no effect, since this family of formats always
1211
require a new repository.
1212
preserve_stacking has no effect, since no source branch using this
1213
family of formats can be stacked, so there is no stacking to preserve.
1215
self._make_tail(url)
1216
result = self._format._initialize_for_clone(url)
1217
self.open_repository().clone(result, revision_id=revision_id)
1218
from_branch = self.open_branch()
1219
from_branch.clone(result, revision_id=revision_id)
1221
tree = self.open_workingtree()
1222
except errors.NotLocalUrl:
1223
# make a new one, this format always has to have one.
1224
result._init_workingtree()
1229
def create_branch(self):
1230
"""See BzrDir.create_branch."""
1231
return self._format.get_branch_format().initialize(self)
1233
def destroy_branch(self):
1234
"""See BzrDir.destroy_branch."""
1235
raise errors.UnsupportedOperation(self.destroy_branch, self)
1237
def create_repository(self, shared=False):
1238
"""See BzrDir.create_repository."""
1240
raise errors.IncompatibleFormat('shared repository', self._format)
1241
return self.open_repository()
1243
def destroy_repository(self):
1244
"""See BzrDir.destroy_repository."""
1245
raise errors.UnsupportedOperation(self.destroy_repository, self)
1247
def create_workingtree(self, revision_id=None, from_branch=None,
1248
accelerator_tree=None, hardlink=False):
1249
"""See BzrDir.create_workingtree."""
1250
# The workingtree is sometimes created when the bzrdir is created,
1251
# but not when cloning.
1253
# this looks buggy but is not -really-
1254
# because this format creates the workingtree when the bzrdir is
1256
# clone and sprout will have set the revision_id
1257
# and that will have set it for us, its only
1258
# specific uses of create_workingtree in isolation
1259
# that can do wonky stuff here, and that only
1260
# happens for creating checkouts, which cannot be
1261
# done on this format anyway. So - acceptable wart.
1263
result = self.open_workingtree(recommend_upgrade=False)
1264
except errors.NoSuchFile:
1265
result = self._init_workingtree()
1266
if revision_id is not None:
1267
if revision_id == _mod_revision.NULL_REVISION:
1268
result.set_parent_ids([])
1270
result.set_parent_ids([revision_id])
1273
def _init_workingtree(self):
1274
from bzrlib.workingtree import WorkingTreeFormat2
1276
return WorkingTreeFormat2().initialize(self)
1277
except errors.NotLocalUrl:
1278
# Even though we can't access the working tree, we need to
1279
# create its control files.
1280
return WorkingTreeFormat2()._stub_initialize_on_transport(
1281
self.transport, self._control_files._file_mode)
1283
def destroy_workingtree(self):
1284
"""See BzrDir.destroy_workingtree."""
1285
raise errors.UnsupportedOperation(self.destroy_workingtree, self)
1287
def destroy_workingtree_metadata(self):
1288
"""See BzrDir.destroy_workingtree_metadata."""
1289
raise errors.UnsupportedOperation(self.destroy_workingtree_metadata,
1292
def get_branch_transport(self, branch_format):
1293
"""See BzrDir.get_branch_transport()."""
1294
if branch_format is None:
1295
return self.transport
1297
branch_format.get_format_string()
1298
except NotImplementedError:
1299
return self.transport
1300
raise errors.IncompatibleFormat(branch_format, self._format)
1302
def get_repository_transport(self, repository_format):
1303
"""See BzrDir.get_repository_transport()."""
1304
if repository_format is None:
1305
return self.transport
1307
repository_format.get_format_string()
1308
except NotImplementedError:
1309
return self.transport
1310
raise errors.IncompatibleFormat(repository_format, self._format)
1312
def get_workingtree_transport(self, workingtree_format):
1313
"""See BzrDir.get_workingtree_transport()."""
1314
if workingtree_format is None:
1315
return self.transport
1317
workingtree_format.get_format_string()
1318
except NotImplementedError:
1319
return self.transport
1320
raise errors.IncompatibleFormat(workingtree_format, self._format)
1322
def needs_format_conversion(self, format=None):
1323
"""See BzrDir.needs_format_conversion()."""
1324
# if the format is not the same as the system default,
1325
# an upgrade is needed.
1327
symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
1328
% 'needs_format_conversion(format=None)')
1329
format = BzrDirFormat.get_default_format()
1330
return not isinstance(self._format, format.__class__)
1332
def open_branch(self, unsupported=False):
1333
"""See BzrDir.open_branch."""
1334
from bzrlib.branch import BzrBranchFormat4
1335
format = BzrBranchFormat4()
1336
self._check_supported(format, unsupported)
1337
return format.open(self, _found=True)
1339
def sprout(self, url, revision_id=None, force_new_repo=False,
1340
possible_transports=None, accelerator_tree=None,
1341
hardlink=False, stacked=False, create_tree_if_local=True):
1342
"""See BzrDir.sprout()."""
1344
raise errors.UnstackableBranchFormat(
1345
self._format, self.root_transport.base)
1346
if not create_tree_if_local:
1347
raise errors.MustHaveWorkingTree(
1348
self._format, self.root_transport.base)
1349
from bzrlib.workingtree import WorkingTreeFormat2
1350
self._make_tail(url)
1351
result = self._format._initialize_for_clone(url)
1353
self.open_repository().clone(result, revision_id=revision_id)
1354
except errors.NoRepositoryPresent:
1357
self.open_branch().sprout(result, revision_id=revision_id)
1358
except errors.NotBranchError:
1361
# we always want a working tree
1362
WorkingTreeFormat2().initialize(result,
1363
accelerator_tree=accelerator_tree,
1368
class BzrDir4(BzrDirPreSplitOut):
1369
"""A .bzr version 4 control object.
1371
This is a deprecated format and may be removed after sept 2006.
1374
def create_repository(self, shared=False):
1375
"""See BzrDir.create_repository."""
1376
return self._format.repository_format.initialize(self, shared)
1378
def needs_format_conversion(self, format=None):
1379
"""Format 4 dirs are always in need of conversion."""
1381
symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
1382
% 'needs_format_conversion(format=None)')
1385
def open_repository(self):
1386
"""See BzrDir.open_repository."""
1387
from bzrlib.repofmt.weaverepo import RepositoryFormat4
1388
return RepositoryFormat4().open(self, _found=True)
1391
class BzrDir5(BzrDirPreSplitOut):
1392
"""A .bzr version 5 control object.
1394
This is a deprecated format and may be removed after sept 2006.
1397
def open_repository(self):
1398
"""See BzrDir.open_repository."""
1399
from bzrlib.repofmt.weaverepo import RepositoryFormat5
1400
return RepositoryFormat5().open(self, _found=True)
1402
def open_workingtree(self, _unsupported=False,
1403
recommend_upgrade=True):
1404
"""See BzrDir.create_workingtree."""
1405
from bzrlib.workingtree import WorkingTreeFormat2
1406
wt_format = WorkingTreeFormat2()
1407
# we don't warn here about upgrades; that ought to be handled for the
1409
return wt_format.open(self, _found=True)
1412
class BzrDir6(BzrDirPreSplitOut):
1413
"""A .bzr version 6 control object.
1415
This is a deprecated format and may be removed after sept 2006.
1418
def open_repository(self):
1419
"""See BzrDir.open_repository."""
1420
from bzrlib.repofmt.weaverepo import RepositoryFormat6
1421
return RepositoryFormat6().open(self, _found=True)
1423
def open_workingtree(self, _unsupported=False,
1424
recommend_upgrade=True):
1425
"""See BzrDir.create_workingtree."""
1426
# we don't warn here about upgrades; that ought to be handled for the
1428
from bzrlib.workingtree import WorkingTreeFormat2
1429
return WorkingTreeFormat2().open(self, _found=True)
1432
class BzrDirMeta1(BzrDir):
1433
"""A .bzr meta version 1 control object.
1435
This is the first control object where the
1436
individual aspects are really split out: there are separate repository,
1437
workingtree and branch subdirectories and any subset of the three can be
1438
present within a BzrDir.
1441
def can_convert_format(self):
1442
"""See BzrDir.can_convert_format()."""
1445
def create_branch(self):
1446
"""See BzrDir.create_branch."""
1447
return self._format.get_branch_format().initialize(self)
1449
def destroy_branch(self):
1450
"""See BzrDir.create_branch."""
1451
self.transport.delete_tree('branch')
1453
def create_repository(self, shared=False):
1454
"""See BzrDir.create_repository."""
1455
return self._format.repository_format.initialize(self, shared)
1457
def destroy_repository(self):
1458
"""See BzrDir.destroy_repository."""
1459
self.transport.delete_tree('repository')
1461
def create_workingtree(self, revision_id=None, from_branch=None,
1462
accelerator_tree=None, hardlink=False):
1463
"""See BzrDir.create_workingtree."""
1464
return self._format.workingtree_format.initialize(
1465
self, revision_id, from_branch=from_branch,
1466
accelerator_tree=accelerator_tree, hardlink=hardlink)
1468
def destroy_workingtree(self):
1469
"""See BzrDir.destroy_workingtree."""
1470
wt = self.open_workingtree(recommend_upgrade=False)
1471
repository = wt.branch.repository
1472
empty = repository.revision_tree(_mod_revision.NULL_REVISION)
1473
wt.revert(old_tree=empty)
1474
self.destroy_workingtree_metadata()
1476
def destroy_workingtree_metadata(self):
1477
self.transport.delete_tree('checkout')
1479
def find_branch_format(self):
1480
"""Find the branch 'format' for this bzrdir.
1482
This might be a synthetic object for e.g. RemoteBranch and SVN.
1484
from bzrlib.branch import BranchFormat
1485
return BranchFormat.find_format(self)
1487
def _get_mkdir_mode(self):
1488
"""Figure out the mode to use when creating a bzrdir subdir."""
1489
temp_control = lockable_files.LockableFiles(self.transport, '',
1490
lockable_files.TransportLock)
1491
return temp_control._dir_mode
1493
def get_branch_reference(self):
1494
"""See BzrDir.get_branch_reference()."""
1495
from bzrlib.branch import BranchFormat
1496
format = BranchFormat.find_format(self)
1497
return format.get_reference(self)
1499
def get_branch_transport(self, branch_format):
1500
"""See BzrDir.get_branch_transport()."""
1501
if branch_format is None:
1502
return self.transport.clone('branch')
1504
branch_format.get_format_string()
1505
except NotImplementedError:
1506
raise errors.IncompatibleFormat(branch_format, self._format)
1508
self.transport.mkdir('branch', mode=self._get_mkdir_mode())
1509
except errors.FileExists:
1511
return self.transport.clone('branch')
1513
def get_repository_transport(self, repository_format):
1514
"""See BzrDir.get_repository_transport()."""
1515
if repository_format is None:
1516
return self.transport.clone('repository')
1518
repository_format.get_format_string()
1519
except NotImplementedError:
1520
raise errors.IncompatibleFormat(repository_format, self._format)
1522
self.transport.mkdir('repository', mode=self._get_mkdir_mode())
1523
except errors.FileExists:
1525
return self.transport.clone('repository')
1527
def get_workingtree_transport(self, workingtree_format):
1528
"""See BzrDir.get_workingtree_transport()."""
1529
if workingtree_format is None:
1530
return self.transport.clone('checkout')
1532
workingtree_format.get_format_string()
1533
except NotImplementedError:
1534
raise errors.IncompatibleFormat(workingtree_format, self._format)
1536
self.transport.mkdir('checkout', mode=self._get_mkdir_mode())
1537
except errors.FileExists:
1539
return self.transport.clone('checkout')
1541
def needs_format_conversion(self, format=None):
1542
"""See BzrDir.needs_format_conversion()."""
1544
symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
1545
% 'needs_format_conversion(format=None)')
1547
format = BzrDirFormat.get_default_format()
1548
if not isinstance(self._format, format.__class__):
1549
# it is not a meta dir format, conversion is needed.
1551
# we might want to push this down to the repository?
1553
if not isinstance(self.open_repository()._format,
1554
format.repository_format.__class__):
1555
# the repository needs an upgrade.
1557
except errors.NoRepositoryPresent:
1560
if not isinstance(self.open_branch()._format,
1561
format.get_branch_format().__class__):
1562
# the branch needs an upgrade.
1564
except errors.NotBranchError:
1567
my_wt = self.open_workingtree(recommend_upgrade=False)
1568
if not isinstance(my_wt._format,
1569
format.workingtree_format.__class__):
1570
# the workingtree needs an upgrade.
1572
except (errors.NoWorkingTree, errors.NotLocalUrl):
1576
def open_branch(self, unsupported=False):
1577
"""See BzrDir.open_branch."""
1578
format = self.find_branch_format()
1579
self._check_supported(format, unsupported)
1580
return format.open(self, _found=True)
1582
def open_repository(self, unsupported=False):
1583
"""See BzrDir.open_repository."""
1584
from bzrlib.repository import RepositoryFormat
1585
format = RepositoryFormat.find_format(self)
1586
self._check_supported(format, unsupported)
1587
return format.open(self, _found=True)
1589
def open_workingtree(self, unsupported=False,
1590
recommend_upgrade=True):
1591
"""See BzrDir.open_workingtree."""
1592
from bzrlib.workingtree import WorkingTreeFormat
1593
format = WorkingTreeFormat.find_format(self)
1594
self._check_supported(format, unsupported,
1596
basedir=self.root_transport.base)
1597
return format.open(self, _found=True)
1599
def _get_config(self):
1600
return config.BzrDirConfig(self.transport)
1603
class BzrDirFormat(object):
1604
"""An encapsulation of the initialization and open routines for a format.
1606
Formats provide three things:
1607
* An initialization routine,
1611
Formats are placed in a dict by their format string for reference
1612
during bzrdir opening. These should be subclasses of BzrDirFormat
1615
Once a format is deprecated, just deprecate the initialize and open
1616
methods on the format class. Do not deprecate the object, as the
1617
object will be created every system load.
1620
_default_format = None
1621
"""The default format used for new .bzr dirs."""
1624
"""The known formats."""
1626
_control_formats = []
1627
"""The registered control formats - .bzr, ....
1629
This is a list of BzrDirFormat objects.
1632
_control_server_formats = []
1633
"""The registered control server formats, e.g. RemoteBzrDirs.
1635
This is a list of BzrDirFormat objects.
1638
_lock_file_name = 'branch-lock'
1640
# _lock_class must be set in subclasses to the lock type, typ.
1641
# TransportLock or LockDir
1644
def find_format(klass, transport, _server_formats=True):
1645
"""Return the format present at transport."""
1647
formats = klass._control_server_formats + klass._control_formats
1649
formats = klass._control_formats
1650
for format in formats:
1652
return format.probe_transport(transport)
1653
except errors.NotBranchError:
1654
# this format does not find a control dir here.
1656
raise errors.NotBranchError(path=transport.base)
1659
def probe_transport(klass, transport):
1660
"""Return the .bzrdir style format present in a directory."""
1662
format_string = transport.get(".bzr/branch-format").read()
1663
except errors.NoSuchFile:
1664
raise errors.NotBranchError(path=transport.base)
1667
return klass._formats[format_string]
1669
raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
1672
def get_default_format(klass):
1673
"""Return the current default format."""
1674
return klass._default_format
1676
def get_format_string(self):
1677
"""Return the ASCII format string that identifies this format."""
1678
raise NotImplementedError(self.get_format_string)
1680
def get_format_description(self):
1681
"""Return the short description for this format."""
1682
raise NotImplementedError(self.get_format_description)
1684
def get_converter(self, format=None):
1685
"""Return the converter to use to convert bzrdirs needing converts.
1687
This returns a bzrlib.bzrdir.Converter object.
1689
This should return the best upgrader to step this format towards the
1690
current default format. In the case of plugins we can/should provide
1691
some means for them to extend the range of returnable converters.
1693
:param format: Optional format to override the default format of the
1696
raise NotImplementedError(self.get_converter)
1698
def initialize(self, url, possible_transports=None):
1699
"""Create a bzr control dir at this url and return an opened copy.
1701
Subclasses should typically override initialize_on_transport
1702
instead of this method.
1704
return self.initialize_on_transport(get_transport(url,
1705
possible_transports))
1707
def initialize_on_transport(self, transport):
1708
"""Initialize a new bzrdir in the base directory of a Transport."""
1709
# Since we don't have a .bzr directory, inherit the
1710
# mode from the root directory
1711
temp_control = lockable_files.LockableFiles(transport,
1712
'', lockable_files.TransportLock)
1713
temp_control._transport.mkdir('.bzr',
1714
# FIXME: RBC 20060121 don't peek under
1716
mode=temp_control._dir_mode)
1717
if sys.platform == 'win32' and isinstance(transport, local.LocalTransport):
1718
win32utils.set_file_attr_hidden(transport._abspath('.bzr'))
1719
file_mode = temp_control._file_mode
1721
bzrdir_transport = transport.clone('.bzr')
1722
utf8_files = [('README',
1723
"This is a Bazaar control directory.\n"
1724
"Do not change any files in this directory.\n"
1725
"See http://bazaar-vcs.org/ for more information about Bazaar.\n"),
1726
('branch-format', self.get_format_string()),
1728
# NB: no need to escape relative paths that are url safe.
1729
control_files = lockable_files.LockableFiles(bzrdir_transport,
1730
self._lock_file_name, self._lock_class)
1731
control_files.create_lock()
1732
control_files.lock_write()
1734
for (filename, content) in utf8_files:
1735
bzrdir_transport.put_bytes(filename, content,
1738
control_files.unlock()
1739
return self.open(transport, _found=True)
1741
def is_supported(self):
1742
"""Is this format supported?
1744
Supported formats must be initializable and openable.
1745
Unsupported formats may not support initialization or committing or
1746
some other features depending on the reason for not being supported.
1750
def same_model(self, target_format):
1751
return (self.repository_format.rich_root_data ==
1752
target_format.rich_root_data)
1755
def known_formats(klass):
1756
"""Return all the known formats.
1758
Concrete formats should override _known_formats.
1760
# There is double indirection here to make sure that control
1761
# formats used by more than one dir format will only be probed
1762
# once. This can otherwise be quite expensive for remote connections.
1764
for format in klass._control_formats:
1765
result.update(format._known_formats())
1769
def _known_formats(klass):
1770
"""Return the known format instances for this control format."""
1771
return set(klass._formats.values())
1773
def open(self, transport, _found=False):
1774
"""Return an instance of this format for the dir transport points at.
1776
_found is a private parameter, do not use it.
1779
found_format = BzrDirFormat.find_format(transport)
1780
if not isinstance(found_format, self.__class__):
1781
raise AssertionError("%s was asked to open %s, but it seems to need "
1783
% (self, transport, found_format))
1784
return self._open(transport)
1786
def _open(self, transport):
1787
"""Template method helper for opening BzrDirectories.
1789
This performs the actual open and any additional logic or parameter
1792
raise NotImplementedError(self._open)
1795
def register_format(klass, format):
1796
klass._formats[format.get_format_string()] = format
1799
def register_control_format(klass, format):
1800
"""Register a format that does not use '.bzr' for its control dir.
1802
TODO: This should be pulled up into a 'ControlDirFormat' base class
1803
which BzrDirFormat can inherit from, and renamed to register_format
1804
there. It has been done without that for now for simplicity of
1807
klass._control_formats.append(format)
1810
def register_control_server_format(klass, format):
1811
"""Register a control format for client-server environments.
1813
These formats will be tried before ones registered with
1814
register_control_format. This gives implementations that decide to the
1815
chance to grab it before anything looks at the contents of the format
1818
klass._control_server_formats.append(format)
1821
def _set_default_format(klass, format):
1822
"""Set default format (for testing behavior of defaults only)"""
1823
klass._default_format = format
1827
return self.get_format_string().rstrip()
1830
def unregister_format(klass, format):
1831
del klass._formats[format.get_format_string()]
1834
def unregister_control_format(klass, format):
1835
klass._control_formats.remove(format)
1838
class BzrDirFormat4(BzrDirFormat):
1839
"""Bzr dir format 4.
1841
This format is a combined format for working tree, branch and repository.
1843
- Format 1 working trees [always]
1844
- Format 4 branches [always]
1845
- Format 4 repositories [always]
1847
This format is deprecated: it indexes texts using a text it which is
1848
removed in format 5; write support for this format has been removed.
1851
_lock_class = lockable_files.TransportLock
1853
def get_format_string(self):
1854
"""See BzrDirFormat.get_format_string()."""
1855
return "Bazaar-NG branch, format 0.0.4\n"
1857
def get_format_description(self):
1858
"""See BzrDirFormat.get_format_description()."""
1859
return "All-in-one format 4"
1861
def get_converter(self, format=None):
1862
"""See BzrDirFormat.get_converter()."""
1863
# there is one and only one upgrade path here.
1864
return ConvertBzrDir4To5()
1866
def initialize_on_transport(self, transport):
1867
"""Format 4 branches cannot be created."""
1868
raise errors.UninitializableFormat(self)
1870
def is_supported(self):
1871
"""Format 4 is not supported.
1873
It is not supported because the model changed from 4 to 5 and the
1874
conversion logic is expensive - so doing it on the fly was not
1879
def _open(self, transport):
1880
"""See BzrDirFormat._open."""
1881
return BzrDir4(transport, self)
1883
def __return_repository_format(self):
1884
"""Circular import protection."""
1885
from bzrlib.repofmt.weaverepo import RepositoryFormat4
1886
return RepositoryFormat4()
1887
repository_format = property(__return_repository_format)
1890
class BzrDirFormat5(BzrDirFormat):
1891
"""Bzr control format 5.
1893
This format is a combined format for working tree, branch and repository.
1895
- Format 2 working trees [always]
1896
- Format 4 branches [always]
1897
- Format 5 repositories [always]
1898
Unhashed stores in the repository.
1901
_lock_class = lockable_files.TransportLock
1903
def get_format_string(self):
1904
"""See BzrDirFormat.get_format_string()."""
1905
return "Bazaar-NG branch, format 5\n"
1907
def get_branch_format(self):
1908
from bzrlib import branch
1909
return branch.BzrBranchFormat4()
1911
def get_format_description(self):
1912
"""See BzrDirFormat.get_format_description()."""
1913
return "All-in-one format 5"
1915
def get_converter(self, format=None):
1916
"""See BzrDirFormat.get_converter()."""
1917
# there is one and only one upgrade path here.
1918
return ConvertBzrDir5To6()
1920
def _initialize_for_clone(self, url):
1921
return self.initialize_on_transport(get_transport(url), _cloning=True)
1923
def initialize_on_transport(self, transport, _cloning=False):
1924
"""Format 5 dirs always have working tree, branch and repository.
1926
Except when they are being cloned.
1928
from bzrlib.branch import BzrBranchFormat4
1929
from bzrlib.repofmt.weaverepo import RepositoryFormat5
1930
result = (super(BzrDirFormat5, self).initialize_on_transport(transport))
1931
RepositoryFormat5().initialize(result, _internal=True)
1933
branch = BzrBranchFormat4().initialize(result)
1934
result._init_workingtree()
1937
def _open(self, transport):
1938
"""See BzrDirFormat._open."""
1939
return BzrDir5(transport, self)
1941
def __return_repository_format(self):
1942
"""Circular import protection."""
1943
from bzrlib.repofmt.weaverepo import RepositoryFormat5
1944
return RepositoryFormat5()
1945
repository_format = property(__return_repository_format)
1948
class BzrDirFormat6(BzrDirFormat):
1949
"""Bzr control format 6.
1951
This format is a combined format for working tree, branch and repository.
1953
- Format 2 working trees [always]
1954
- Format 4 branches [always]
1955
- Format 6 repositories [always]
1958
_lock_class = lockable_files.TransportLock
1960
def get_format_string(self):
1961
"""See BzrDirFormat.get_format_string()."""
1962
return "Bazaar-NG branch, format 6\n"
1964
def get_format_description(self):
1965
"""See BzrDirFormat.get_format_description()."""
1966
return "All-in-one format 6"
1968
def get_branch_format(self):
1969
from bzrlib import branch
1970
return branch.BzrBranchFormat4()
1972
def get_converter(self, format=None):
1973
"""See BzrDirFormat.get_converter()."""
1974
# there is one and only one upgrade path here.
1975
return ConvertBzrDir6ToMeta()
1977
def _initialize_for_clone(self, url):
1978
return self.initialize_on_transport(get_transport(url), _cloning=True)
1980
def initialize_on_transport(self, transport, _cloning=False):
1981
"""Format 6 dirs always have working tree, branch and repository.
1983
Except when they are being cloned.
1985
from bzrlib.branch import BzrBranchFormat4
1986
from bzrlib.repofmt.weaverepo import RepositoryFormat6
1987
result = super(BzrDirFormat6, self).initialize_on_transport(transport)
1988
RepositoryFormat6().initialize(result, _internal=True)
1990
branch = BzrBranchFormat4().initialize(result)
1991
result._init_workingtree()
1994
def _open(self, transport):
1995
"""See BzrDirFormat._open."""
1996
return BzrDir6(transport, self)
1998
def __return_repository_format(self):
1999
"""Circular import protection."""
2000
from bzrlib.repofmt.weaverepo import RepositoryFormat6
2001
return RepositoryFormat6()
2002
repository_format = property(__return_repository_format)
2005
class BzrDirMetaFormat1(BzrDirFormat):
2006
"""Bzr meta control format 1
2008
This is the first format with split out working tree, branch and repository
2011
- Format 3 working trees [optional]
2012
- Format 5 branches [optional]
2013
- Format 7 repositories [optional]
2016
_lock_class = lockdir.LockDir
2019
self._workingtree_format = None
2020
self._branch_format = None
2022
def __eq__(self, other):
2023
if other.__class__ is not self.__class__:
2025
if other.repository_format != self.repository_format:
2027
if other.workingtree_format != self.workingtree_format:
2031
def __ne__(self, other):
2032
return not self == other
2034
def get_branch_format(self):
2035
if self._branch_format is None:
2036
from bzrlib.branch import BranchFormat
2037
self._branch_format = BranchFormat.get_default_format()
2038
return self._branch_format
2040
def set_branch_format(self, format):
2041
self._branch_format = format
2043
def require_stacking(self):
2044
if not self.get_branch_format().supports_stacking():
2045
# We need to make a stacked branch, but the default format for the
2046
# target doesn't support stacking. So force a branch that *can*
2048
from bzrlib.branch import BzrBranchFormat7
2049
self._branch_format = BzrBranchFormat7()
2050
mutter("using %r for stacking" % (self._branch_format,))
2051
from bzrlib.repofmt import pack_repo
2052
if self.repository_format.rich_root_data:
2053
bzrdir_format_name = '1.6.1-rich-root'
2054
repo_format = pack_repo.RepositoryFormatKnitPack5RichRoot()
2056
bzrdir_format_name = '1.6'
2057
repo_format = pack_repo.RepositoryFormatKnitPack5()
2058
note('Source format does not support stacking, using format:'
2060
bzrdir_format_name, repo_format.get_format_description())
2061
self.repository_format = repo_format
2063
def get_converter(self, format=None):
2064
"""See BzrDirFormat.get_converter()."""
2066
format = BzrDirFormat.get_default_format()
2067
if not isinstance(self, format.__class__):
2068
# converting away from metadir is not implemented
2069
raise NotImplementedError(self.get_converter)
2070
return ConvertMetaToMeta(format)
2072
def get_format_string(self):
2073
"""See BzrDirFormat.get_format_string()."""
2074
return "Bazaar-NG meta directory, format 1\n"
2076
def get_format_description(self):
2077
"""See BzrDirFormat.get_format_description()."""
2078
return "Meta directory format 1"
2080
def _open(self, transport):
2081
"""See BzrDirFormat._open."""
2082
return BzrDirMeta1(transport, self)
2084
def __return_repository_format(self):
2085
"""Circular import protection."""
2086
if getattr(self, '_repository_format', None):
2087
return self._repository_format
2088
from bzrlib.repository import RepositoryFormat
2089
return RepositoryFormat.get_default_format()
2091
def __set_repository_format(self, value):
2092
"""Allow changing the repository format for metadir formats."""
2093
self._repository_format = value
2095
repository_format = property(__return_repository_format, __set_repository_format)
2097
def __get_workingtree_format(self):
2098
if self._workingtree_format is None:
2099
from bzrlib.workingtree import WorkingTreeFormat
2100
self._workingtree_format = WorkingTreeFormat.get_default_format()
2101
return self._workingtree_format
2103
def __set_workingtree_format(self, wt_format):
2104
self._workingtree_format = wt_format
2106
workingtree_format = property(__get_workingtree_format,
2107
__set_workingtree_format)
2110
# Register bzr control format
2111
BzrDirFormat.register_control_format(BzrDirFormat)
2113
# Register bzr formats
2114
BzrDirFormat.register_format(BzrDirFormat4())
2115
BzrDirFormat.register_format(BzrDirFormat5())
2116
BzrDirFormat.register_format(BzrDirFormat6())
2117
__default_format = BzrDirMetaFormat1()
2118
BzrDirFormat.register_format(__default_format)
2119
BzrDirFormat._default_format = __default_format
2122
class Converter(object):
2123
"""Converts a disk format object from one format to another."""
2125
def convert(self, to_convert, pb):
2126
"""Perform the conversion of to_convert, giving feedback via pb.
2128
:param to_convert: The disk object to convert.
2129
:param pb: a progress bar to use for progress information.
2132
def step(self, message):
2133
"""Update the pb by a step."""
2135
self.pb.update(message, self.count, self.total)
2138
class ConvertBzrDir4To5(Converter):
2139
"""Converts format 4 bzr dirs to format 5."""
2142
super(ConvertBzrDir4To5, self).__init__()
2143
self.converted_revs = set()
2144
self.absent_revisions = set()
2148
def convert(self, to_convert, pb):
2149
"""See Converter.convert()."""
2150
self.bzrdir = to_convert
2152
self.pb.note('starting upgrade from format 4 to 5')
2153
if isinstance(self.bzrdir.transport, local.LocalTransport):
2154
self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
2155
self._convert_to_weaves()
2156
return BzrDir.open(self.bzrdir.root_transport.base)
2158
def _convert_to_weaves(self):
2159
self.pb.note('note: upgrade may be faster if all store files are ungzipped first')
2162
stat = self.bzrdir.transport.stat('weaves')
2163
if not S_ISDIR(stat.st_mode):
2164
self.bzrdir.transport.delete('weaves')
2165
self.bzrdir.transport.mkdir('weaves')
2166
except errors.NoSuchFile:
2167
self.bzrdir.transport.mkdir('weaves')
2168
# deliberately not a WeaveFile as we want to build it up slowly.
2169
self.inv_weave = Weave('inventory')
2170
# holds in-memory weaves for all files
2171
self.text_weaves = {}
2172
self.bzrdir.transport.delete('branch-format')
2173
self.branch = self.bzrdir.open_branch()
2174
self._convert_working_inv()
2175
rev_history = self.branch.revision_history()
2176
# to_read is a stack holding the revisions we still need to process;
2177
# appending to it adds new highest-priority revisions
2178
self.known_revisions = set(rev_history)
2179
self.to_read = rev_history[-1:]
2181
rev_id = self.to_read.pop()
2182
if (rev_id not in self.revisions
2183
and rev_id not in self.absent_revisions):
2184
self._load_one_rev(rev_id)
2186
to_import = self._make_order()
2187
for i, rev_id in enumerate(to_import):
2188
self.pb.update('converting revision', i, len(to_import))
2189
self._convert_one_rev(rev_id)
2191
self._write_all_weaves()
2192
self._write_all_revs()
2193
self.pb.note('upgraded to weaves:')
2194
self.pb.note(' %6d revisions and inventories', len(self.revisions))
2195
self.pb.note(' %6d revisions not present', len(self.absent_revisions))
2196
self.pb.note(' %6d texts', self.text_count)
2197
self._cleanup_spare_files_after_format4()
2198
self.branch._transport.put_bytes(
2200
BzrDirFormat5().get_format_string(),
2201
mode=self.bzrdir._get_file_mode())
2203
def _cleanup_spare_files_after_format4(self):
2204
# FIXME working tree upgrade foo.
2205
for n in 'merged-patches', 'pending-merged-patches':
2207
## assert os.path.getsize(p) == 0
2208
self.bzrdir.transport.delete(n)
2209
except errors.NoSuchFile:
2211
self.bzrdir.transport.delete_tree('inventory-store')
2212
self.bzrdir.transport.delete_tree('text-store')
2214
def _convert_working_inv(self):
2215
inv = xml4.serializer_v4.read_inventory(
2216
self.branch._transport.get('inventory'))
2217
new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv, working=True)
2218
self.branch._transport.put_bytes('inventory', new_inv_xml,
2219
mode=self.bzrdir._get_file_mode())
2221
def _write_all_weaves(self):
2222
controlweaves = WeaveStore(self.bzrdir.transport, prefixed=False)
2223
weave_transport = self.bzrdir.transport.clone('weaves')
2224
weaves = WeaveStore(weave_transport, prefixed=False)
2225
transaction = WriteTransaction()
2229
for file_id, file_weave in self.text_weaves.items():
2230
self.pb.update('writing weave', i, len(self.text_weaves))
2231
weaves._put_weave(file_id, file_weave, transaction)
2233
self.pb.update('inventory', 0, 1)
2234
controlweaves._put_weave('inventory', self.inv_weave, transaction)
2235
self.pb.update('inventory', 1, 1)
2239
def _write_all_revs(self):
2240
"""Write all revisions out in new form."""
2241
self.bzrdir.transport.delete_tree('revision-store')
2242
self.bzrdir.transport.mkdir('revision-store')
2243
revision_transport = self.bzrdir.transport.clone('revision-store')
2245
from bzrlib.xml5 import serializer_v5
2246
from bzrlib.repofmt.weaverepo import RevisionTextStore
2247
revision_store = RevisionTextStore(revision_transport,
2248
serializer_v5, False, versionedfile.PrefixMapper(),
2249
lambda:True, lambda:True)
2251
for i, rev_id in enumerate(self.converted_revs):
2252
self.pb.update('write revision', i, len(self.converted_revs))
2253
text = serializer_v5.write_revision_to_string(
2254
self.revisions[rev_id])
2256
revision_store.add_lines(key, None, osutils.split_lines(text))
2260
def _load_one_rev(self, rev_id):
2261
"""Load a revision object into memory.
2263
Any parents not either loaded or abandoned get queued to be
2265
self.pb.update('loading revision',
2266
len(self.revisions),
2267
len(self.known_revisions))
2268
if not self.branch.repository.has_revision(rev_id):
2270
self.pb.note('revision {%s} not present in branch; '
2271
'will be converted as a ghost',
2273
self.absent_revisions.add(rev_id)
2275
rev = self.branch.repository.get_revision(rev_id)
2276
for parent_id in rev.parent_ids:
2277
self.known_revisions.add(parent_id)
2278
self.to_read.append(parent_id)
2279
self.revisions[rev_id] = rev
2281
def _load_old_inventory(self, rev_id):
2282
old_inv_xml = self.branch.repository.inventory_store.get(rev_id).read()
2283
inv = xml4.serializer_v4.read_inventory_from_string(old_inv_xml)
2284
inv.revision_id = rev_id
2285
rev = self.revisions[rev_id]
2288
def _load_updated_inventory(self, rev_id):
2289
inv_xml = self.inv_weave.get_text(rev_id)
2290
inv = xml5.serializer_v5.read_inventory_from_string(inv_xml, rev_id)
2293
def _convert_one_rev(self, rev_id):
2294
"""Convert revision and all referenced objects to new format."""
2295
rev = self.revisions[rev_id]
2296
inv = self._load_old_inventory(rev_id)
2297
present_parents = [p for p in rev.parent_ids
2298
if p not in self.absent_revisions]
2299
self._convert_revision_contents(rev, inv, present_parents)
2300
self._store_new_inv(rev, inv, present_parents)
2301
self.converted_revs.add(rev_id)
2303
def _store_new_inv(self, rev, inv, present_parents):
2304
new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
2305
new_inv_sha1 = sha_string(new_inv_xml)
2306
self.inv_weave.add_lines(rev.revision_id,
2308
new_inv_xml.splitlines(True))
2309
rev.inventory_sha1 = new_inv_sha1
2311
def _convert_revision_contents(self, rev, inv, present_parents):
2312
"""Convert all the files within a revision.
2314
Also upgrade the inventory to refer to the text revision ids."""
2315
rev_id = rev.revision_id
2316
mutter('converting texts of revision {%s}',
2318
parent_invs = map(self._load_updated_inventory, present_parents)
2319
entries = inv.iter_entries()
2321
for path, ie in entries:
2322
self._convert_file_version(rev, ie, parent_invs)
2324
def _convert_file_version(self, rev, ie, parent_invs):
2325
"""Convert one version of one file.
2327
The file needs to be added into the weave if it is a merge
2328
of >=2 parents or if it's changed from its parent.
2330
file_id = ie.file_id
2331
rev_id = rev.revision_id
2332
w = self.text_weaves.get(file_id)
2335
self.text_weaves[file_id] = w
2336
text_changed = False
2337
parent_candiate_entries = ie.parent_candidates(parent_invs)
2338
heads = graph.Graph(self).heads(parent_candiate_entries.keys())
2339
# XXX: Note that this is unordered - and this is tolerable because
2340
# the previous code was also unordered.
2341
previous_entries = dict((head, parent_candiate_entries[head]) for head
2343
self.snapshot_ie(previous_entries, ie, w, rev_id)
2346
@symbol_versioning.deprecated_method(symbol_versioning.one_one)
2347
def get_parents(self, revision_ids):
2348
for revision_id in revision_ids:
2349
yield self.revisions[revision_id].parent_ids
2351
def get_parent_map(self, revision_ids):
2352
"""See graph._StackedParentsProvider.get_parent_map"""
2353
return dict((revision_id, self.revisions[revision_id])
2354
for revision_id in revision_ids
2355
if revision_id in self.revisions)
2357
def snapshot_ie(self, previous_revisions, ie, w, rev_id):
2358
# TODO: convert this logic, which is ~= snapshot to
2359
# a call to:. This needs the path figured out. rather than a work_tree
2360
# a v4 revision_tree can be given, or something that looks enough like
2361
# one to give the file content to the entry if it needs it.
2362
# and we need something that looks like a weave store for snapshot to
2364
#ie.snapshot(rev, PATH, previous_revisions, REVISION_TREE, InMemoryWeaveStore(self.text_weaves))
2365
if len(previous_revisions) == 1:
2366
previous_ie = previous_revisions.values()[0]
2367
if ie._unchanged(previous_ie):
2368
ie.revision = previous_ie.revision
2371
text = self.branch.repository._text_store.get(ie.text_id)
2372
file_lines = text.readlines()
2373
w.add_lines(rev_id, previous_revisions, file_lines)
2374
self.text_count += 1
2376
w.add_lines(rev_id, previous_revisions, [])
2377
ie.revision = rev_id
2379
def _make_order(self):
2380
"""Return a suitable order for importing revisions.
2382
The order must be such that an revision is imported after all
2383
its (present) parents.
2385
todo = set(self.revisions.keys())
2386
done = self.absent_revisions.copy()
2389
# scan through looking for a revision whose parents
2391
for rev_id in sorted(list(todo)):
2392
rev = self.revisions[rev_id]
2393
parent_ids = set(rev.parent_ids)
2394
if parent_ids.issubset(done):
2395
# can take this one now
2396
order.append(rev_id)
2402
class ConvertBzrDir5To6(Converter):
2403
"""Converts format 5 bzr dirs to format 6."""
2405
def convert(self, to_convert, pb):
2406
"""See Converter.convert()."""
2407
self.bzrdir = to_convert
2409
self.pb.note('starting upgrade from format 5 to 6')
2410
self._convert_to_prefixed()
2411
return BzrDir.open(self.bzrdir.root_transport.base)
2413
def _convert_to_prefixed(self):
2414
from bzrlib.store import TransportStore
2415
self.bzrdir.transport.delete('branch-format')
2416
for store_name in ["weaves", "revision-store"]:
2417
self.pb.note("adding prefixes to %s" % store_name)
2418
store_transport = self.bzrdir.transport.clone(store_name)
2419
store = TransportStore(store_transport, prefixed=True)
2420
for urlfilename in store_transport.list_dir('.'):
2421
filename = urlutils.unescape(urlfilename)
2422
if (filename.endswith(".weave") or
2423
filename.endswith(".gz") or
2424
filename.endswith(".sig")):
2425
file_id, suffix = os.path.splitext(filename)
2429
new_name = store._mapper.map((file_id,)) + suffix
2430
# FIXME keep track of the dirs made RBC 20060121
2432
store_transport.move(filename, new_name)
2433
except errors.NoSuchFile: # catches missing dirs strangely enough
2434
store_transport.mkdir(osutils.dirname(new_name))
2435
store_transport.move(filename, new_name)
2436
self.bzrdir.transport.put_bytes(
2438
BzrDirFormat6().get_format_string(),
2439
mode=self.bzrdir._get_file_mode())
2442
class ConvertBzrDir6ToMeta(Converter):
2443
"""Converts format 6 bzr dirs to metadirs."""
2445
def convert(self, to_convert, pb):
2446
"""See Converter.convert()."""
2447
from bzrlib.repofmt.weaverepo import RepositoryFormat7
2448
from bzrlib.branch import BzrBranchFormat5
2449
self.bzrdir = to_convert
2452
self.total = 20 # the steps we know about
2453
self.garbage_inventories = []
2454
self.dir_mode = self.bzrdir._get_dir_mode()
2455
self.file_mode = self.bzrdir._get_file_mode()
2457
self.pb.note('starting upgrade from format 6 to metadir')
2458
self.bzrdir.transport.put_bytes(
2460
"Converting to format 6",
2461
mode=self.file_mode)
2462
# its faster to move specific files around than to open and use the apis...
2463
# first off, nuke ancestry.weave, it was never used.
2465
self.step('Removing ancestry.weave')
2466
self.bzrdir.transport.delete('ancestry.weave')
2467
except errors.NoSuchFile:
2469
# find out whats there
2470
self.step('Finding branch files')
2471
last_revision = self.bzrdir.open_branch().last_revision()
2472
bzrcontents = self.bzrdir.transport.list_dir('.')
2473
for name in bzrcontents:
2474
if name.startswith('basis-inventory.'):
2475
self.garbage_inventories.append(name)
2476
# create new directories for repository, working tree and branch
2477
repository_names = [('inventory.weave', True),
2478
('revision-store', True),
2480
self.step('Upgrading repository ')
2481
self.bzrdir.transport.mkdir('repository', mode=self.dir_mode)
2482
self.make_lock('repository')
2483
# we hard code the formats here because we are converting into
2484
# the meta format. The meta format upgrader can take this to a
2485
# future format within each component.
2486
self.put_format('repository', RepositoryFormat7())
2487
for entry in repository_names:
2488
self.move_entry('repository', entry)
2490
self.step('Upgrading branch ')
2491
self.bzrdir.transport.mkdir('branch', mode=self.dir_mode)
2492
self.make_lock('branch')
2493
self.put_format('branch', BzrBranchFormat5())
2494
branch_files = [('revision-history', True),
2495
('branch-name', True),
2497
for entry in branch_files:
2498
self.move_entry('branch', entry)
2500
checkout_files = [('pending-merges', True),
2501
('inventory', True),
2502
('stat-cache', False)]
2503
# If a mandatory checkout file is not present, the branch does not have
2504
# a functional checkout. Do not create a checkout in the converted
2506
for name, mandatory in checkout_files:
2507
if mandatory and name not in bzrcontents:
2508
has_checkout = False
2512
if not has_checkout:
2513
self.pb.note('No working tree.')
2514
# If some checkout files are there, we may as well get rid of them.
2515
for name, mandatory in checkout_files:
2516
if name in bzrcontents:
2517
self.bzrdir.transport.delete(name)
2519
from bzrlib.workingtree import WorkingTreeFormat3
2520
self.step('Upgrading working tree')
2521
self.bzrdir.transport.mkdir('checkout', mode=self.dir_mode)
2522
self.make_lock('checkout')
2524
'checkout', WorkingTreeFormat3())
2525
self.bzrdir.transport.delete_multi(
2526
self.garbage_inventories, self.pb)
2527
for entry in checkout_files:
2528
self.move_entry('checkout', entry)
2529
if last_revision is not None:
2530
self.bzrdir.transport.put_bytes(
2531
'checkout/last-revision', last_revision)
2532
self.bzrdir.transport.put_bytes(
2534
BzrDirMetaFormat1().get_format_string(),
2535
mode=self.file_mode)
2536
return BzrDir.open(self.bzrdir.root_transport.base)
2538
def make_lock(self, name):
2539
"""Make a lock for the new control dir name."""
2540
self.step('Make %s lock' % name)
2541
ld = lockdir.LockDir(self.bzrdir.transport,
2543
file_modebits=self.file_mode,
2544
dir_modebits=self.dir_mode)
2547
def move_entry(self, new_dir, entry):
2548
"""Move then entry name into new_dir."""
2550
mandatory = entry[1]
2551
self.step('Moving %s' % name)
2553
self.bzrdir.transport.move(name, '%s/%s' % (new_dir, name))
2554
except errors.NoSuchFile:
2558
def put_format(self, dirname, format):
2559
self.bzrdir.transport.put_bytes('%s/format' % dirname,
2560
format.get_format_string(),
2564
class ConvertMetaToMeta(Converter):
2565
"""Converts the components of metadirs."""
2567
def __init__(self, target_format):
2568
"""Create a metadir to metadir converter.
2570
:param target_format: The final metadir format that is desired.
2572
self.target_format = target_format
2574
def convert(self, to_convert, pb):
2575
"""See Converter.convert()."""
2576
self.bzrdir = to_convert
2580
self.step('checking repository format')
2582
repo = self.bzrdir.open_repository()
2583
except errors.NoRepositoryPresent:
2586
if not isinstance(repo._format, self.target_format.repository_format.__class__):
2587
from bzrlib.repository import CopyConverter
2588
self.pb.note('starting repository conversion')
2589
converter = CopyConverter(self.target_format.repository_format)
2590
converter.convert(repo, pb)
2592
branch = self.bzrdir.open_branch()
2593
except errors.NotBranchError:
2596
# TODO: conversions of Branch and Tree should be done by
2597
# InterXFormat lookups/some sort of registry.
2598
# Avoid circular imports
2599
from bzrlib import branch as _mod_branch
2600
old = branch._format.__class__
2601
new = self.target_format.get_branch_format().__class__
2603
if (old == _mod_branch.BzrBranchFormat5 and
2604
new in (_mod_branch.BzrBranchFormat6,
2605
_mod_branch.BzrBranchFormat7)):
2606
branch_converter = _mod_branch.Converter5to6()
2607
elif (old == _mod_branch.BzrBranchFormat6 and
2608
new == _mod_branch.BzrBranchFormat7):
2609
branch_converter = _mod_branch.Converter6to7()
2611
raise errors.BadConversionTarget("No converter", new)
2612
branch_converter.convert(branch)
2613
branch = self.bzrdir.open_branch()
2614
old = branch._format.__class__
2616
tree = self.bzrdir.open_workingtree(recommend_upgrade=False)
2617
except (errors.NoWorkingTree, errors.NotLocalUrl):
2620
# TODO: conversions of Branch and Tree should be done by
2621
# InterXFormat lookups
2622
if (isinstance(tree, workingtree.WorkingTree3) and
2623
not isinstance(tree, workingtree_4.DirStateWorkingTree) and
2624
isinstance(self.target_format.workingtree_format,
2625
workingtree_4.DirStateWorkingTreeFormat)):
2626
workingtree_4.Converter3to4().convert(tree)
2627
if (isinstance(tree, workingtree_4.DirStateWorkingTree) and
2628
not isinstance(tree, workingtree_4.WorkingTree5) and
2629
isinstance(self.target_format.workingtree_format,
2630
workingtree_4.WorkingTreeFormat5)):
2631
workingtree_4.Converter4to5().convert(tree)
2635
# This is not in remote.py because it's small, and needs to be registered.
2636
# Putting it in remote.py creates a circular import problem.
2637
# we can make it a lazy object if the control formats is turned into something
2639
class RemoteBzrDirFormat(BzrDirMetaFormat1):
2640
"""Format representing bzrdirs accessed via a smart server"""
2642
def get_format_description(self):
2643
return 'bzr remote bzrdir'
2646
def probe_transport(klass, transport):
2647
"""Return a RemoteBzrDirFormat object if it looks possible."""
2649
medium = transport.get_smart_medium()
2650
except (NotImplementedError, AttributeError,
2651
errors.TransportNotPossible, errors.NoSmartMedium,
2652
errors.SmartProtocolError):
2653
# no smart server, so not a branch for this format type.
2654
raise errors.NotBranchError(path=transport.base)
2656
# Decline to open it if the server doesn't support our required
2657
# version (3) so that the VFS-based transport will do it.
2658
if medium.should_probe():
2660
server_version = medium.protocol_version()
2661
except errors.SmartProtocolError:
2662
# Apparently there's no usable smart server there, even though
2663
# the medium supports the smart protocol.
2664
raise errors.NotBranchError(path=transport.base)
2665
if server_version != '2':
2666
raise errors.NotBranchError(path=transport.base)
2669
def initialize_on_transport(self, transport):
2671
# hand off the request to the smart server
2672
client_medium = transport.get_smart_medium()
2673
except errors.NoSmartMedium:
2674
# TODO: lookup the local format from a server hint.
2675
local_dir_format = BzrDirMetaFormat1()
2676
return local_dir_format.initialize_on_transport(transport)
2677
client = _SmartClient(client_medium)
2678
path = client.remote_path_from_transport(transport)
2679
response = client.call('BzrDirFormat.initialize', path)
2680
if response[0] != 'ok':
2681
raise errors.SmartProtocolError('unexpected response code %s' % (response,))
2682
return remote.RemoteBzrDir(transport)
2684
def _open(self, transport):
2685
return remote.RemoteBzrDir(transport)
2687
def __eq__(self, other):
2688
if not isinstance(other, RemoteBzrDirFormat):
2690
return self.get_format_description() == other.get_format_description()
2693
def repository_format(self):
2694
# Using a property to avoid early loading of remote
2695
return remote.RemoteRepositoryFormat()
2698
BzrDirFormat.register_control_server_format(RemoteBzrDirFormat)
2701
class BzrDirFormatInfo(object):
2703
def __init__(self, native, deprecated, hidden, experimental):
2704
self.deprecated = deprecated
2705
self.native = native
2706
self.hidden = hidden
2707
self.experimental = experimental
2710
class BzrDirFormatRegistry(registry.Registry):
2711
"""Registry of user-selectable BzrDir subformats.
2713
Differs from BzrDirFormat._control_formats in that it provides sub-formats,
2714
e.g. BzrDirMeta1 with weave repository. Also, it's more user-oriented.
2718
"""Create a BzrDirFormatRegistry."""
2719
self._aliases = set()
2720
self._registration_order = list()
2721
super(BzrDirFormatRegistry, self).__init__()
2724
"""Return a set of the format names which are aliases."""
2725
return frozenset(self._aliases)
2727
def register_metadir(self, key,
2728
repository_format, help, native=True, deprecated=False,
2734
"""Register a metadir subformat.
2736
These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
2737
by the Repository format.
2739
:param repository_format: The fully-qualified repository format class
2741
:param branch_format: Fully-qualified branch format class name as
2743
:param tree_format: Fully-qualified tree format class name as
2746
# This should be expanded to support setting WorkingTree and Branch
2747
# formats, once BzrDirMetaFormat1 supports that.
2748
def _load(full_name):
2749
mod_name, factory_name = full_name.rsplit('.', 1)
2751
mod = __import__(mod_name, globals(), locals(),
2753
except ImportError, e:
2754
raise ImportError('failed to load %s: %s' % (full_name, e))
2756
factory = getattr(mod, factory_name)
2757
except AttributeError:
2758
raise AttributeError('no factory %s in module %r'
2763
bd = BzrDirMetaFormat1()
2764
if branch_format is not None:
2765
bd.set_branch_format(_load(branch_format))
2766
if tree_format is not None:
2767
bd.workingtree_format = _load(tree_format)
2768
if repository_format is not None:
2769
bd.repository_format = _load(repository_format)
2771
self.register(key, helper, help, native, deprecated, hidden,
2772
experimental, alias)
2774
def register(self, key, factory, help, native=True, deprecated=False,
2775
hidden=False, experimental=False, alias=False):
2776
"""Register a BzrDirFormat factory.
2778
The factory must be a callable that takes one parameter: the key.
2779
It must produce an instance of the BzrDirFormat when called.
2781
This function mainly exists to prevent the info object from being
2784
registry.Registry.register(self, key, factory, help,
2785
BzrDirFormatInfo(native, deprecated, hidden, experimental))
2787
self._aliases.add(key)
2788
self._registration_order.append(key)
2790
def register_lazy(self, key, module_name, member_name, help, native=True,
2791
deprecated=False, hidden=False, experimental=False, alias=False):
2792
registry.Registry.register_lazy(self, key, module_name, member_name,
2793
help, BzrDirFormatInfo(native, deprecated, hidden, experimental))
2795
self._aliases.add(key)
2796
self._registration_order.append(key)
2798
def set_default(self, key):
2799
"""Set the 'default' key to be a clone of the supplied key.
2801
This method must be called once and only once.
2803
registry.Registry.register(self, 'default', self.get(key),
2804
self.get_help(key), info=self.get_info(key))
2805
self._aliases.add('default')
2807
def set_default_repository(self, key):
2808
"""Set the FormatRegistry default and Repository default.
2810
This is a transitional method while Repository.set_default_format
2813
if 'default' in self:
2814
self.remove('default')
2815
self.set_default(key)
2816
format = self.get('default')()
2818
def make_bzrdir(self, key):
2819
return self.get(key)()
2821
def help_topic(self, topic):
2823
default_realkey = None
2824
default_help = self.get_help('default')
2826
for key in self._registration_order:
2827
if key == 'default':
2829
help = self.get_help(key)
2830
if help == default_help:
2831
default_realkey = key
2833
help_pairs.append((key, help))
2835
def wrapped(key, help, info):
2837
help = '(native) ' + help
2838
return ':%s:\n%s\n\n' % (key,
2839
textwrap.fill(help, initial_indent=' ',
2840
subsequent_indent=' '))
2841
if default_realkey is not None:
2842
output += wrapped(default_realkey, '(default) %s' % default_help,
2843
self.get_info('default'))
2844
deprecated_pairs = []
2845
experimental_pairs = []
2846
for key, help in help_pairs:
2847
info = self.get_info(key)
2850
elif info.deprecated:
2851
deprecated_pairs.append((key, help))
2852
elif info.experimental:
2853
experimental_pairs.append((key, help))
2855
output += wrapped(key, help, info)
2856
output += "\nSee ``bzr help formats`` for more about storage formats."
2858
if len(experimental_pairs) > 0:
2859
other_output += "Experimental formats are shown below.\n\n"
2860
for key, help in experimental_pairs:
2861
info = self.get_info(key)
2862
other_output += wrapped(key, help, info)
2865
"No experimental formats are available.\n\n"
2866
if len(deprecated_pairs) > 0:
2867
other_output += "\nDeprecated formats are shown below.\n\n"
2868
for key, help in deprecated_pairs:
2869
info = self.get_info(key)
2870
other_output += wrapped(key, help, info)
2873
"\nNo deprecated formats are available.\n\n"
2875
"\nSee ``bzr help formats`` for more about storage formats."
2877
if topic == 'other-formats':
2883
class RepositoryAcquisitionPolicy(object):
2884
"""Abstract base class for repository acquisition policies.
2886
A repository acquisition policy decides how a BzrDir acquires a repository
2887
for a branch that is being created. The most basic policy decision is
2888
whether to create a new repository or use an existing one.
2890
def __init__(self, stack_on, stack_on_pwd, require_stacking):
2893
:param stack_on: A location to stack on
2894
:param stack_on_pwd: If stack_on is relative, the location it is
2896
:param require_stacking: If True, it is a failure to not stack.
2898
self._stack_on = stack_on
2899
self._stack_on_pwd = stack_on_pwd
2900
self._require_stacking = require_stacking
2902
def configure_branch(self, branch):
2903
"""Apply any configuration data from this policy to the branch.
2905
Default implementation sets repository stacking.
2907
if self._stack_on is None:
2909
if self._stack_on_pwd is None:
2910
stack_on = self._stack_on
2913
stack_on = urlutils.rebase_url(self._stack_on,
2915
branch.bzrdir.root_transport.base)
2916
except errors.InvalidRebaseURLs:
2917
stack_on = self._get_full_stack_on()
2919
branch.set_stacked_on_url(stack_on)
2920
except errors.UnstackableBranchFormat:
2921
if self._require_stacking:
2924
def _get_full_stack_on(self):
2925
"""Get a fully-qualified URL for the stack_on location."""
2926
if self._stack_on is None:
2928
if self._stack_on_pwd is None:
2929
return self._stack_on
2931
return urlutils.join(self._stack_on_pwd, self._stack_on)
2933
def _add_fallback(self, repository, possible_transports=None):
2934
"""Add a fallback to the supplied repository, if stacking is set."""
2935
stack_on = self._get_full_stack_on()
2936
if stack_on is None:
2938
stacked_dir = BzrDir.open(stack_on,
2939
possible_transports=possible_transports)
2941
stacked_repo = stacked_dir.open_branch().repository
2942
except errors.NotBranchError:
2943
stacked_repo = stacked_dir.open_repository()
2945
repository.add_fallback_repository(stacked_repo)
2946
except errors.UnstackableRepositoryFormat:
2947
if self._require_stacking:
2950
self._require_stacking = True
2952
def acquire_repository(self, make_working_trees=None, shared=False):
2953
"""Acquire a repository for this bzrdir.
2955
Implementations may create a new repository or use a pre-exising
2957
:param make_working_trees: If creating a repository, set
2958
make_working_trees to this value (if non-None)
2959
:param shared: If creating a repository, make it shared if True
2960
:return: A repository
2962
raise NotImplemented(RepositoryAcquisitionPolicy.acquire_repository)
2965
class CreateRepository(RepositoryAcquisitionPolicy):
2966
"""A policy of creating a new repository"""
2968
def __init__(self, bzrdir, stack_on=None, stack_on_pwd=None,
2969
require_stacking=False):
2972
:param bzrdir: The bzrdir to create the repository on.
2973
:param stack_on: A location to stack on
2974
:param stack_on_pwd: If stack_on is relative, the location it is
2977
RepositoryAcquisitionPolicy.__init__(self, stack_on, stack_on_pwd,
2979
self._bzrdir = bzrdir
2981
def acquire_repository(self, make_working_trees=None, shared=False):
2982
"""Implementation of RepositoryAcquisitionPolicy.acquire_repository
2984
Creates the desired repository in the bzrdir we already have.
2986
repository = self._bzrdir.create_repository(shared=shared)
2987
self._add_fallback(repository,
2988
possible_transports=[self._bzrdir.transport])
2989
if make_working_trees is not None:
2990
repository.set_make_working_trees(make_working_trees)
2994
class UseExistingRepository(RepositoryAcquisitionPolicy):
2995
"""A policy of reusing an existing repository"""
2997
def __init__(self, repository, stack_on=None, stack_on_pwd=None,
2998
require_stacking=False):
3001
:param repository: The repository to use.
3002
:param stack_on: A location to stack on
3003
:param stack_on_pwd: If stack_on is relative, the location it is
3006
RepositoryAcquisitionPolicy.__init__(self, stack_on, stack_on_pwd,
3008
self._repository = repository
3010
def acquire_repository(self, make_working_trees=None, shared=False):
3011
"""Implementation of RepositoryAcquisitionPolicy.acquire_repository
3013
Returns an existing repository to use
3015
self._add_fallback(self._repository,
3016
possible_transports=[self._repository.bzrdir.transport])
3017
return self._repository
3020
# Please register new formats after old formats so that formats
3021
# appear in chronological order and format descriptions can build
3023
format_registry = BzrDirFormatRegistry()
3024
format_registry.register('weave', BzrDirFormat6,
3025
'Pre-0.8 format. Slower than knit and does not'
3026
' support checkouts or shared repositories.',
3028
format_registry.register_metadir('metaweave',
3029
'bzrlib.repofmt.weaverepo.RepositoryFormat7',
3030
'Transitional format in 0.8. Slower than knit.',
3031
branch_format='bzrlib.branch.BzrBranchFormat5',
3032
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3034
format_registry.register_metadir('knit',
3035
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3036
'Format using knits. Recommended for interoperation with bzr <= 0.14.',
3037
branch_format='bzrlib.branch.BzrBranchFormat5',
3038
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3040
format_registry.register_metadir('dirstate',
3041
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3042
help='New in 0.15: Fast local operations. Compatible with bzr 0.8 and '
3043
'above when accessed over the network.',
3044
branch_format='bzrlib.branch.BzrBranchFormat5',
3045
# this uses bzrlib.workingtree.WorkingTreeFormat4 because importing
3046
# directly from workingtree_4 triggers a circular import.
3047
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3049
format_registry.register_metadir('dirstate-tags',
3050
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3051
help='New in 0.15: Fast local operations and improved scaling for '
3052
'network operations. Additionally adds support for tags.'
3053
' Incompatible with bzr < 0.15.',
3054
branch_format='bzrlib.branch.BzrBranchFormat6',
3055
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3057
format_registry.register_metadir('rich-root',
3058
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit4',
3059
help='New in 1.0. Better handling of tree roots. Incompatible with'
3061
branch_format='bzrlib.branch.BzrBranchFormat6',
3062
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3064
format_registry.register_metadir('dirstate-with-subtree',
3065
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
3066
help='New in 0.15: Fast local operations and improved scaling for '
3067
'network operations. Additionally adds support for versioning nested '
3068
'bzr branches. Incompatible with bzr < 0.15.',
3069
branch_format='bzrlib.branch.BzrBranchFormat6',
3070
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3074
format_registry.register_metadir('pack-0.92',
3075
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack1',
3076
help='New in 0.92: Pack-based format with data compatible with '
3077
'dirstate-tags format repositories. Interoperates with '
3078
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3079
'Previously called knitpack-experimental. '
3080
'For more information, see '
3081
'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
3082
branch_format='bzrlib.branch.BzrBranchFormat6',
3083
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3085
format_registry.register_metadir('pack-0.92-subtree',
3086
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack3',
3087
help='New in 0.92: Pack-based format with data compatible with '
3088
'dirstate-with-subtree format repositories. Interoperates with '
3089
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3090
'Previously called knitpack-experimental. '
3091
'For more information, see '
3092
'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
3093
branch_format='bzrlib.branch.BzrBranchFormat6',
3094
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3098
format_registry.register_metadir('rich-root-pack',
3099
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack4',
3100
help='New in 1.0: A variant of pack-0.92 that supports rich-root data '
3101
'(needed for bzr-svn).',
3102
branch_format='bzrlib.branch.BzrBranchFormat6',
3103
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3105
format_registry.register_metadir('1.6',
3106
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5',
3107
help='A format that allows a branch to indicate that there is another '
3108
'(stacked) repository that should be used to access data that is '
3109
'not present locally.',
3110
branch_format='bzrlib.branch.BzrBranchFormat7',
3111
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3113
format_registry.register_metadir('1.6.1-rich-root',
3114
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5RichRoot',
3115
help='A variant of 1.6 that supports rich-root data '
3116
'(needed for bzr-svn).',
3117
branch_format='bzrlib.branch.BzrBranchFormat7',
3118
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3120
format_registry.register_metadir('1.9',
3121
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3122
help='A repository format using B+tree indexes. These indexes '
3123
'are smaller in size, have smarter caching and provide faster '
3124
'performance for most operations.',
3125
branch_format='bzrlib.branch.BzrBranchFormat7',
3126
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3128
format_registry.register_metadir('1.9-rich-root',
3129
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3130
help='A variant of 1.9 that supports rich-root data '
3131
'(needed for bzr-svn).',
3132
branch_format='bzrlib.branch.BzrBranchFormat7',
3133
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3135
format_registry.register_metadir('development-wt5',
3136
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3137
help='A working-tree format that supports views and content filtering.',
3138
branch_format='bzrlib.branch.BzrBranchFormat7',
3139
tree_format='bzrlib.workingtree.WorkingTreeFormat5',
3142
format_registry.register_metadir('development-wt5-rich-root',
3143
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3144
help='A variant of development-wt5 that supports rich-root data '
3145
'(needed for bzr-svn).',
3146
branch_format='bzrlib.branch.BzrBranchFormat7',
3147
tree_format='bzrlib.workingtree.WorkingTreeFormat5',
3150
# The following two formats should always just be aliases.
3151
format_registry.register_metadir('development',
3152
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2',
3153
help='Current development format. Can convert data to and from pack-0.92 '
3154
'(and anything compatible with pack-0.92) format repositories. '
3155
'Repositories and branches in this format can only be read by bzr.dev. '
3157
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3159
branch_format='bzrlib.branch.BzrBranchFormat7',
3160
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3164
format_registry.register_metadir('development-subtree',
3165
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
3166
help='Current development format, subtree variant. Can convert data to and '
3167
'from pack-0.92-subtree (and anything compatible with '
3168
'pack-0.92-subtree) format repositories. Repositories and branches in '
3169
'this format can only be read by bzr.dev. Please read '
3170
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3172
branch_format='bzrlib.branch.BzrBranchFormat7',
3173
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3177
# And the development formats above will have aliased one of the following:
3178
format_registry.register_metadir('development2',
3179
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2',
3180
help='1.6.1 with B+Tree based index. '
3182
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3184
branch_format='bzrlib.branch.BzrBranchFormat7',
3185
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3189
format_registry.register_metadir('development2-subtree',
3190
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
3191
help='1.6.1-subtree with B+Tree based index. '
3193
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3195
branch_format='bzrlib.branch.BzrBranchFormat7',
3196
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3200
# The current format that is made on 'bzr init'.
3201
format_registry.set_default('pack-0.92')
added
removed
bzrlib/bzrdir.py
