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,
67
remote as remote_transport,
69
from bzrlib.weave import Weave
72
from bzrlib.trace import (
84
"""A .bzr control diretory.
86
BzrDir instances let you create or open any of the things that can be
87
found within .bzr - checkouts, branches and repositories.
90
the transport which this bzr dir is rooted at (i.e. file:///.../.bzr/)
92
a transport connected to the directory this bzr was opened from
93
(i.e. the parent directory holding the .bzr directory).
95
Everything in the bzrdir should have the same file permissions.
99
"""Invoke break_lock on the first object in the bzrdir.
101
If there is a tree, the tree is opened and break_lock() called.
102
Otherwise, branch is tried, and finally repository.
104
# XXX: This seems more like a UI function than something that really
105
# belongs in this class.
107
thing_to_unlock = self.open_workingtree()
108
except (errors.NotLocalUrl, errors.NoWorkingTree):
110
thing_to_unlock = self.open_branch()
111
except errors.NotBranchError:
113
thing_to_unlock = self.open_repository()
114
except errors.NoRepositoryPresent:
116
thing_to_unlock.break_lock()
118
def can_convert_format(self):
119
"""Return true if this bzrdir is one whose format we can convert from."""
122
def check_conversion_target(self, target_format):
123
target_repo_format = target_format.repository_format
124
source_repo_format = self._format.repository_format
125
source_repo_format.check_conversion_target(target_repo_format)
128
def _check_supported(format, allow_unsupported,
129
recommend_upgrade=True,
131
"""Give an error or warning on old formats.
133
:param format: may be any kind of format - workingtree, branch,
136
:param allow_unsupported: If true, allow opening
137
formats that are strongly deprecated, and which may
138
have limited functionality.
140
:param recommend_upgrade: If true (default), warn
141
the user through the ui object that they may wish
142
to upgrade the object.
144
# TODO: perhaps move this into a base Format class; it's not BzrDir
145
# specific. mbp 20070323
146
if not allow_unsupported and not format.is_supported():
147
# see open_downlevel to open legacy branches.
148
raise errors.UnsupportedFormatError(format=format)
149
if recommend_upgrade \
150
and getattr(format, 'upgrade_recommended', False):
151
ui.ui_factory.recommend_upgrade(
152
format.get_format_description(),
155
def clone(self, url, revision_id=None, force_new_repo=False,
156
preserve_stacking=False):
157
"""Clone this bzrdir and its contents to url verbatim.
159
:param url: The url create the clone at. If url's last component does
160
not exist, it will be created.
161
:param revision_id: The tip revision-id to use for any branch or
162
working tree. If not None, then the clone operation may tune
163
itself to download less data.
164
:param force_new_repo: Do not use a shared repository for the target
165
even if one is available.
166
:param preserve_stacking: When cloning a stacked branch, stack the
167
new branch on top of the other branch's stacked-on branch.
169
return self.clone_on_transport(get_transport(url),
170
revision_id=revision_id,
171
force_new_repo=force_new_repo,
172
preserve_stacking=preserve_stacking)
174
def clone_on_transport(self, transport, revision_id=None,
175
force_new_repo=False, preserve_stacking=False,
177
"""Clone this bzrdir and its contents to transport verbatim.
179
:param transport: The transport for the location to produce the clone
180
at. If the target directory does not exist, it will be created.
181
:param revision_id: The tip revision-id to use for any branch or
182
working tree. If not None, then the clone operation may tune
183
itself to download less data.
184
:param force_new_repo: Do not use a shared repository for the target,
185
even if one is available.
186
:param preserve_stacking: When cloning a stacked branch, stack the
187
new branch on top of the other branch's stacked-on branch.
189
transport.ensure_base()
190
require_stacking = (stacked_on is not None)
191
format = self.cloning_metadir(require_stacking)
192
result = format.initialize_on_transport(transport)
193
repository_policy = None
195
local_repo = self.find_repository()
196
except errors.NoRepositoryPresent:
199
local_branch = self.open_branch()
200
except errors.NotBranchError:
203
# enable fallbacks when branch is not a branch reference
204
if local_branch.repository.has_same_location(local_repo):
205
local_repo = local_branch.repository
206
if preserve_stacking:
208
stacked_on = local_branch.get_stacked_on_url()
209
except (errors.UnstackableBranchFormat,
210
errors.UnstackableRepositoryFormat,
215
# may need to copy content in
216
repository_policy = result.determine_repository_policy(
217
force_new_repo, stacked_on, self.root_transport.base,
218
require_stacking=require_stacking)
219
make_working_trees = local_repo.make_working_trees()
220
result_repo = repository_policy.acquire_repository(
221
make_working_trees, local_repo.is_shared())
222
if not require_stacking and repository_policy._require_stacking:
223
require_stacking = True
224
result._format.require_stacking()
225
result_repo.fetch(local_repo, revision_id=revision_id)
228
# 1 if there is a branch present
229
# make sure its content is available in the target repository
231
if local_branch is not None:
232
result_branch = local_branch.clone(result, revision_id=revision_id)
233
if repository_policy is not None:
234
repository_policy.configure_branch(result_branch)
235
if result_repo is None or result_repo.make_working_trees():
237
self.open_workingtree().clone(result)
238
except (errors.NoWorkingTree, errors.NotLocalUrl):
242
# TODO: This should be given a Transport, and should chdir up; otherwise
243
# this will open a new connection.
244
def _make_tail(self, url):
245
t = get_transport(url)
249
def create(cls, base, format=None, possible_transports=None):
250
"""Create a new BzrDir at the url 'base'.
252
:param format: If supplied, the format of branch to create. If not
253
supplied, the default is used.
254
:param possible_transports: If supplied, a list of transports that
255
can be reused to share a remote connection.
257
if cls is not BzrDir:
258
raise AssertionError("BzrDir.create always creates the default"
259
" format, not one of %r" % cls)
260
t = get_transport(base, possible_transports)
263
format = BzrDirFormat.get_default_format()
264
return format.initialize_on_transport(t)
267
def find_bzrdirs(transport, evaluate=None, list_current=None):
268
"""Find bzrdirs recursively from current location.
270
This is intended primarily as a building block for more sophisticated
271
functionality, like finding trees under a directory, or finding
272
branches that use a given repository.
273
:param evaluate: An optional callable that yields recurse, value,
274
where recurse controls whether this bzrdir is recursed into
275
and value is the value to yield. By default, all bzrdirs
276
are recursed into, and the return value is the bzrdir.
277
:param list_current: if supplied, use this function to list the current
278
directory, instead of Transport.list_dir
279
:return: a generator of found bzrdirs, or whatever evaluate returns.
281
if list_current is None:
282
def list_current(transport):
283
return transport.list_dir('')
285
def evaluate(bzrdir):
288
pending = [transport]
289
while len(pending) > 0:
290
current_transport = pending.pop()
293
bzrdir = BzrDir.open_from_transport(current_transport)
294
except errors.NotBranchError:
297
recurse, value = evaluate(bzrdir)
300
subdirs = list_current(current_transport)
301
except errors.NoSuchFile:
304
for subdir in sorted(subdirs, reverse=True):
305
pending.append(current_transport.clone(subdir))
308
def find_branches(transport):
309
"""Find all branches under a transport.
311
This will find all branches below the transport, including branches
312
inside other branches. Where possible, it will use
313
Repository.find_branches.
315
To list all the branches that use a particular Repository, see
316
Repository.find_branches
318
def evaluate(bzrdir):
320
repository = bzrdir.open_repository()
321
except errors.NoRepositoryPresent:
324
return False, (None, repository)
326
branch = bzrdir.open_branch()
327
except errors.NotBranchError:
328
return True, (None, None)
330
return True, (branch, None)
332
for branch, repo in BzrDir.find_bzrdirs(transport, evaluate=evaluate):
334
branches.extend(repo.find_branches())
335
if branch is not None:
336
branches.append(branch)
339
def destroy_repository(self):
340
"""Destroy the repository in this BzrDir"""
341
raise NotImplementedError(self.destroy_repository)
343
def create_branch(self):
344
"""Create a branch in this BzrDir.
346
The bzrdir's format will control what branch format is created.
347
For more control see BranchFormatXX.create(a_bzrdir).
349
raise NotImplementedError(self.create_branch)
351
def destroy_branch(self):
352
"""Destroy the branch in this BzrDir"""
353
raise NotImplementedError(self.destroy_branch)
356
def create_branch_and_repo(base, force_new_repo=False, format=None):
357
"""Create a new BzrDir, Branch and Repository at the url 'base'.
359
This will use the current default BzrDirFormat unless one is
360
specified, and use whatever
361
repository format that that uses via bzrdir.create_branch and
362
create_repository. If a shared repository is available that is used
365
The created Branch object is returned.
367
:param base: The URL to create the branch at.
368
:param force_new_repo: If True a new repository is always created.
369
:param format: If supplied, the format of branch to create. If not
370
supplied, the default is used.
372
bzrdir = BzrDir.create(base, format)
373
bzrdir._find_or_create_repository(force_new_repo)
374
return bzrdir.create_branch()
376
def determine_repository_policy(self, force_new_repo=False, stack_on=None,
377
stack_on_pwd=None, require_stacking=False):
378
"""Return an object representing a policy to use.
380
This controls whether a new repository is created, or a shared
381
repository used instead.
383
If stack_on is supplied, will not seek a containing shared repo.
385
:param force_new_repo: If True, require a new repository to be created.
386
:param stack_on: If supplied, the location to stack on. If not
387
supplied, a default_stack_on location may be used.
388
:param stack_on_pwd: If stack_on is relative, the location it is
391
def repository_policy(found_bzrdir):
394
config = found_bzrdir.get_config()
396
if config is not None:
397
stack_on = config.get_default_stack_on()
398
if stack_on is not None:
399
stack_on_pwd = found_bzrdir.root_transport.base
401
note('Using default stacking branch %s at %s', stack_on,
403
# does it have a repository ?
405
repository = found_bzrdir.open_repository()
406
except errors.NoRepositoryPresent:
409
if ((found_bzrdir.root_transport.base !=
410
self.root_transport.base) and not repository.is_shared()):
417
return UseExistingRepository(repository, stack_on,
418
stack_on_pwd, require_stacking=require_stacking), True
420
return CreateRepository(self, stack_on, stack_on_pwd,
421
require_stacking=require_stacking), True
423
if not force_new_repo:
425
policy = self._find_containing(repository_policy)
426
if policy is not None:
430
return UseExistingRepository(self.open_repository(),
431
stack_on, stack_on_pwd,
432
require_stacking=require_stacking)
433
except errors.NoRepositoryPresent:
435
return CreateRepository(self, stack_on, stack_on_pwd,
436
require_stacking=require_stacking)
438
def _find_or_create_repository(self, force_new_repo):
439
"""Create a new repository if needed, returning the repository."""
440
policy = self.determine_repository_policy(force_new_repo)
441
return policy.acquire_repository()
444
def create_branch_convenience(base, force_new_repo=False,
445
force_new_tree=None, format=None,
446
possible_transports=None):
447
"""Create a new BzrDir, Branch and Repository at the url 'base'.
449
This is a convenience function - it will use an existing repository
450
if possible, can be told explicitly whether to create a working tree or
453
This will use the current default BzrDirFormat unless one is
454
specified, and use whatever
455
repository format that that uses via bzrdir.create_branch and
456
create_repository. If a shared repository is available that is used
457
preferentially. Whatever repository is used, its tree creation policy
460
The created Branch object is returned.
461
If a working tree cannot be made due to base not being a file:// url,
462
no error is raised unless force_new_tree is True, in which case no
463
data is created on disk and NotLocalUrl is raised.
465
:param base: The URL to create the branch at.
466
:param force_new_repo: If True a new repository is always created.
467
:param force_new_tree: If True or False force creation of a tree or
468
prevent such creation respectively.
469
:param format: Override for the bzrdir format to create.
470
:param possible_transports: An optional reusable transports list.
473
# check for non local urls
474
t = get_transport(base, possible_transports)
475
if not isinstance(t, local.LocalTransport):
476
raise errors.NotLocalUrl(base)
477
bzrdir = BzrDir.create(base, format, possible_transports)
478
repo = bzrdir._find_or_create_repository(force_new_repo)
479
result = bzrdir.create_branch()
480
if force_new_tree or (repo.make_working_trees() and
481
force_new_tree is None):
483
bzrdir.create_workingtree()
484
except errors.NotLocalUrl:
489
def create_standalone_workingtree(base, format=None):
490
"""Create a new BzrDir, WorkingTree, Branch and Repository at 'base'.
492
'base' must be a local path or a file:// url.
494
This will use the current default BzrDirFormat unless one is
495
specified, and use whatever
496
repository format that that uses for bzrdirformat.create_workingtree,
497
create_branch and create_repository.
499
:param format: Override for the bzrdir format to create.
500
:return: The WorkingTree object.
502
t = get_transport(base)
503
if not isinstance(t, local.LocalTransport):
504
raise errors.NotLocalUrl(base)
505
bzrdir = BzrDir.create_branch_and_repo(base,
507
format=format).bzrdir
508
return bzrdir.create_workingtree()
510
def create_workingtree(self, revision_id=None, from_branch=None,
511
accelerator_tree=None, hardlink=False):
512
"""Create a working tree at this BzrDir.
514
:param revision_id: create it as of this revision id.
515
:param from_branch: override bzrdir branch (for lightweight checkouts)
516
:param accelerator_tree: A tree which can be used for retrieving file
517
contents more quickly than the revision tree, i.e. a workingtree.
518
The revision tree will be used for cases where accelerator_tree's
519
content is different.
521
raise NotImplementedError(self.create_workingtree)
523
def backup_bzrdir(self):
524
"""Backup this bzr control directory.
526
:return: Tuple with old path name and new path name
528
pb = ui.ui_factory.nested_progress_bar()
530
# FIXME: bug 300001 -- the backup fails if the backup directory
531
# already exists, but it should instead either remove it or make
532
# a new backup directory.
534
# FIXME: bug 262450 -- the backup directory should have the same
535
# permissions as the .bzr directory (probably a bug in copy_tree)
536
old_path = self.root_transport.abspath('.bzr')
537
new_path = self.root_transport.abspath('backup.bzr')
538
pb.note('making backup of %s' % (old_path,))
539
pb.note(' to %s' % (new_path,))
540
self.root_transport.copy_tree('.bzr', 'backup.bzr')
541
return (old_path, new_path)
545
def retire_bzrdir(self, limit=10000):
546
"""Permanently disable the bzrdir.
548
This is done by renaming it to give the user some ability to recover
549
if there was a problem.
551
This will have horrible consequences if anyone has anything locked or
553
:param limit: number of times to retry
558
to_path = '.bzr.retired.%d' % i
559
self.root_transport.rename('.bzr', to_path)
560
note("renamed %s to %s"
561
% (self.root_transport.abspath('.bzr'), to_path))
563
except (errors.TransportError, IOError, errors.PathError):
570
def destroy_workingtree(self):
571
"""Destroy the working tree at this BzrDir.
573
Formats that do not support this may raise UnsupportedOperation.
575
raise NotImplementedError(self.destroy_workingtree)
577
def destroy_workingtree_metadata(self):
578
"""Destroy the control files for the working tree at this BzrDir.
580
The contents of working tree files are not affected.
581
Formats that do not support this may raise UnsupportedOperation.
583
raise NotImplementedError(self.destroy_workingtree_metadata)
585
def _find_containing(self, evaluate):
586
"""Find something in a containing control directory.
588
This method will scan containing control dirs, until it finds what
589
it is looking for, decides that it will never find it, or runs out
590
of containing control directories to check.
592
It is used to implement find_repository and
593
determine_repository_policy.
595
:param evaluate: A function returning (value, stop). If stop is True,
596
the value will be returned.
600
result, stop = evaluate(found_bzrdir)
603
next_transport = found_bzrdir.root_transport.clone('..')
604
if (found_bzrdir.root_transport.base == next_transport.base):
605
# top of the file system
607
# find the next containing bzrdir
609
found_bzrdir = BzrDir.open_containing_from_transport(
611
except errors.NotBranchError:
614
def find_repository(self):
615
"""Find the repository that should be used.
617
This does not require a branch as we use it to find the repo for
618
new branches as well as to hook existing branches up to their
621
def usable_repository(found_bzrdir):
622
# does it have a repository ?
624
repository = found_bzrdir.open_repository()
625
except errors.NoRepositoryPresent:
627
if found_bzrdir.root_transport.base == self.root_transport.base:
628
return repository, True
629
elif repository.is_shared():
630
return repository, True
634
found_repo = self._find_containing(usable_repository)
635
if found_repo is None:
636
raise errors.NoRepositoryPresent(self)
639
def get_branch_reference(self):
640
"""Return the referenced URL for the branch in this bzrdir.
642
:raises NotBranchError: If there is no Branch.
643
:return: The URL the branch in this bzrdir references if it is a
644
reference branch, or None for regular branches.
648
def get_branch_transport(self, branch_format):
649
"""Get the transport for use by branch format in this BzrDir.
651
Note that bzr dirs that do not support format strings will raise
652
IncompatibleFormat if the branch format they are given has
653
a format string, and vice versa.
655
If branch_format is None, the transport is returned with no
656
checking. If it is not None, then the returned transport is
657
guaranteed to point to an existing directory ready for use.
659
raise NotImplementedError(self.get_branch_transport)
661
def _find_creation_modes(self):
662
"""Determine the appropriate modes for files and directories.
664
They're always set to be consistent with the base directory,
665
assuming that this transport allows setting modes.
667
# TODO: Do we need or want an option (maybe a config setting) to turn
668
# this off or override it for particular locations? -- mbp 20080512
669
if self._mode_check_done:
671
self._mode_check_done = True
673
st = self.transport.stat('.')
674
except errors.TransportNotPossible:
675
self._dir_mode = None
676
self._file_mode = None
678
# Check the directory mode, but also make sure the created
679
# directories and files are read-write for this user. This is
680
# mostly a workaround for filesystems which lie about being able to
681
# write to a directory (cygwin & win32)
682
if (st.st_mode & 07777 == 00000):
683
# FTP allows stat but does not return dir/file modes
684
self._dir_mode = None
685
self._file_mode = None
687
self._dir_mode = (st.st_mode & 07777) | 00700
688
# Remove the sticky and execute bits for files
689
self._file_mode = self._dir_mode & ~07111
691
def _get_file_mode(self):
692
"""Return Unix mode for newly created files, or None.
694
if not self._mode_check_done:
695
self._find_creation_modes()
696
return self._file_mode
698
def _get_dir_mode(self):
699
"""Return Unix mode for newly created directories, or None.
701
if not self._mode_check_done:
702
self._find_creation_modes()
703
return self._dir_mode
705
def get_repository_transport(self, repository_format):
706
"""Get the transport for use by repository format in this BzrDir.
708
Note that bzr dirs that do not support format strings will raise
709
IncompatibleFormat if the repository format they are given has
710
a format string, and vice versa.
712
If repository_format is None, the transport is returned with no
713
checking. If it is not None, then the returned transport is
714
guaranteed to point to an existing directory ready for use.
716
raise NotImplementedError(self.get_repository_transport)
718
def get_workingtree_transport(self, tree_format):
719
"""Get the transport for use by workingtree format in this BzrDir.
721
Note that bzr dirs that do not support format strings will raise
722
IncompatibleFormat if the workingtree format they are given has a
723
format string, and vice versa.
725
If workingtree_format is None, the transport is returned with no
726
checking. If it is not None, then the returned transport is
727
guaranteed to point to an existing directory ready for use.
729
raise NotImplementedError(self.get_workingtree_transport)
731
def get_config(self):
732
if getattr(self, '_get_config', None) is None:
734
return self._get_config()
736
def __init__(self, _transport, _format):
737
"""Initialize a Bzr control dir object.
739
Only really common logic should reside here, concrete classes should be
740
made with varying behaviours.
742
:param _format: the format that is creating this BzrDir instance.
743
:param _transport: the transport this dir is based at.
745
self._format = _format
746
self.transport = _transport.clone('.bzr')
747
self.root_transport = _transport
748
self._mode_check_done = False
750
def is_control_filename(self, filename):
751
"""True if filename is the name of a path which is reserved for bzrdir's.
753
:param filename: A filename within the root transport of this bzrdir.
755
This is true IF and ONLY IF the filename is part of the namespace reserved
756
for bzr control dirs. Currently this is the '.bzr' directory in the root
757
of the root_transport. it is expected that plugins will need to extend
758
this in the future - for instance to make bzr talk with svn working
761
# this might be better on the BzrDirFormat class because it refers to
762
# all the possible bzrdir disk formats.
763
# This method is tested via the workingtree is_control_filename tests-
764
# it was extracted from WorkingTree.is_control_filename. If the method's
765
# contract is extended beyond the current trivial implementation, please
766
# add new tests for it to the appropriate place.
767
return filename == '.bzr' or filename.startswith('.bzr/')
769
def needs_format_conversion(self, format=None):
770
"""Return true if this bzrdir needs convert_format run on it.
772
For instance, if the repository format is out of date but the
773
branch and working tree are not, this should return True.
775
:param format: Optional parameter indicating a specific desired
776
format we plan to arrive at.
778
raise NotImplementedError(self.needs_format_conversion)
781
def open_unsupported(base):
782
"""Open a branch which is not supported."""
783
return BzrDir.open(base, _unsupported=True)
786
def open(base, _unsupported=False, possible_transports=None):
787
"""Open an existing bzrdir, rooted at 'base' (url).
789
:param _unsupported: a private parameter to the BzrDir class.
791
t = get_transport(base, possible_transports=possible_transports)
792
return BzrDir.open_from_transport(t, _unsupported=_unsupported)
795
def open_from_transport(transport, _unsupported=False,
796
_server_formats=True):
797
"""Open a bzrdir within a particular directory.
799
:param transport: Transport containing the bzrdir.
800
:param _unsupported: private.
802
# Keep initial base since 'transport' may be modified while following
804
base = transport.base
805
def find_format(transport):
806
return transport, BzrDirFormat.find_format(
807
transport, _server_formats=_server_formats)
809
def redirected(transport, e, redirection_notice):
810
redirected_transport = transport._redirected_to(e.source, e.target)
811
if redirected_transport is None:
812
raise errors.NotBranchError(base)
813
note('%s is%s redirected to %s',
814
transport.base, e.permanently, redirected_transport.base)
815
return redirected_transport
818
transport, format = do_catching_redirections(find_format,
821
except errors.TooManyRedirections:
822
raise errors.NotBranchError(base)
824
BzrDir._check_supported(format, _unsupported)
825
return format.open(transport, _found=True)
827
def open_branch(self, unsupported=False):
828
"""Open the branch object at this BzrDir if one is present.
830
If unsupported is True, then no longer supported branch formats can
833
TODO: static convenience version of this?
835
raise NotImplementedError(self.open_branch)
838
def open_containing(url, possible_transports=None):
839
"""Open an existing branch which contains url.
841
:param url: url to search from.
842
See open_containing_from_transport for more detail.
844
transport = get_transport(url, possible_transports)
845
return BzrDir.open_containing_from_transport(transport)
848
def open_containing_from_transport(a_transport):
849
"""Open an existing branch which contains a_transport.base.
851
This probes for a branch at a_transport, and searches upwards from there.
853
Basically we keep looking up until we find the control directory or
854
run into the root. If there isn't one, raises NotBranchError.
855
If there is one and it is either an unrecognised format or an unsupported
856
format, UnknownFormatError or UnsupportedFormatError are raised.
857
If there is one, it is returned, along with the unused portion of url.
859
:return: The BzrDir that contains the path, and a Unicode path
860
for the rest of the URL.
862
# this gets the normalised url back. I.e. '.' -> the full path.
863
url = a_transport.base
866
result = BzrDir.open_from_transport(a_transport)
867
return result, urlutils.unescape(a_transport.relpath(url))
868
except errors.NotBranchError, e:
871
new_t = a_transport.clone('..')
872
except errors.InvalidURLJoin:
873
# reached the root, whatever that may be
874
raise errors.NotBranchError(path=url)
875
if new_t.base == a_transport.base:
876
# reached the root, whatever that may be
877
raise errors.NotBranchError(path=url)
880
def _get_tree_branch(self):
881
"""Return the branch and tree, if any, for this bzrdir.
883
Return None for tree if not present or inaccessible.
884
Raise NotBranchError if no branch is present.
885
:return: (tree, branch)
888
tree = self.open_workingtree()
889
except (errors.NoWorkingTree, errors.NotLocalUrl):
891
branch = self.open_branch()
897
def open_tree_or_branch(klass, location):
898
"""Return the branch and working tree at a location.
900
If there is no tree at the location, tree will be None.
901
If there is no branch at the location, an exception will be
903
:return: (tree, branch)
905
bzrdir = klass.open(location)
906
return bzrdir._get_tree_branch()
909
def open_containing_tree_or_branch(klass, location):
910
"""Return the branch and working tree contained by a location.
912
Returns (tree, branch, relpath).
913
If there is no tree at containing the location, tree will be None.
914
If there is no branch containing the location, an exception will be
916
relpath is the portion of the path that is contained by the branch.
918
bzrdir, relpath = klass.open_containing(location)
919
tree, branch = bzrdir._get_tree_branch()
920
return tree, branch, relpath
923
def open_containing_tree_branch_or_repository(klass, location):
924
"""Return the working tree, branch and repo contained by a location.
926
Returns (tree, branch, repository, relpath).
927
If there is no tree containing the location, tree will be None.
928
If there is no branch containing the location, branch will be None.
929
If there is no repository containing the location, repository will be
931
relpath is the portion of the path that is contained by the innermost
934
If no tree, branch or repository is found, a NotBranchError is raised.
936
bzrdir, relpath = klass.open_containing(location)
938
tree, branch = bzrdir._get_tree_branch()
939
except errors.NotBranchError:
941
repo = bzrdir.find_repository()
942
return None, None, repo, relpath
943
except (errors.NoRepositoryPresent):
944
raise errors.NotBranchError(location)
945
return tree, branch, branch.repository, relpath
947
def open_repository(self, _unsupported=False):
948
"""Open the repository object at this BzrDir if one is present.
950
This will not follow the Branch object pointer - it's strictly a direct
951
open facility. Most client code should use open_branch().repository to
954
:param _unsupported: a private parameter, not part of the api.
955
TODO: static convenience version of this?
957
raise NotImplementedError(self.open_repository)
959
def open_workingtree(self, _unsupported=False,
960
recommend_upgrade=True, from_branch=None):
961
"""Open the workingtree object at this BzrDir if one is present.
963
:param recommend_upgrade: Optional keyword parameter, when True (the
964
default), emit through the ui module a recommendation that the user
965
upgrade the working tree when the workingtree being opened is old
966
(but still fully supported).
967
:param from_branch: override bzrdir branch (for lightweight checkouts)
969
raise NotImplementedError(self.open_workingtree)
971
def has_branch(self):
972
"""Tell if this bzrdir contains a branch.
974
Note: if you're going to open the branch, you should just go ahead
975
and try, and not ask permission first. (This method just opens the
976
branch and discards it, and that's somewhat expensive.)
981
except errors.NotBranchError:
984
def has_workingtree(self):
985
"""Tell if this bzrdir contains a working tree.
987
This will still raise an exception if the bzrdir has a workingtree that
988
is remote & inaccessible.
990
Note: if you're going to open the working tree, you should just go ahead
991
and try, and not ask permission first. (This method just opens the
992
workingtree and discards it, and that's somewhat expensive.)
995
self.open_workingtree(recommend_upgrade=False)
997
except errors.NoWorkingTree:
1000
def _cloning_metadir(self):
1001
"""Produce a metadir suitable for cloning with.
1003
:returns: (destination_bzrdir_format, source_repository)
1005
result_format = self._format.__class__()
1008
branch = self.open_branch()
1009
source_repository = branch.repository
1010
result_format._branch_format = branch._format
1011
except errors.NotBranchError:
1012
source_branch = None
1013
source_repository = self.open_repository()
1014
except errors.NoRepositoryPresent:
1015
source_repository = None
1017
# XXX TODO: This isinstance is here because we have not implemented
1018
# the fix recommended in bug # 103195 - to delegate this choice the
1019
# repository itself.
1020
repo_format = source_repository._format
1021
if isinstance(repo_format, remote.RemoteRepositoryFormat):
1022
source_repository._ensure_real()
1023
repo_format = source_repository._real_repository._format
1024
result_format.repository_format = repo_format
1026
# TODO: Couldn't we just probe for the format in these cases,
1027
# rather than opening the whole tree? It would be a little
1028
# faster. mbp 20070401
1029
tree = self.open_workingtree(recommend_upgrade=False)
1030
except (errors.NoWorkingTree, errors.NotLocalUrl):
1031
result_format.workingtree_format = None
1033
result_format.workingtree_format = tree._format.__class__()
1034
return result_format, source_repository
1036
def cloning_metadir(self, require_stacking=False):
1037
"""Produce a metadir suitable for cloning or sprouting with.
1039
These operations may produce workingtrees (yes, even though they're
1040
"cloning" something that doesn't have a tree), so a viable workingtree
1041
format must be selected.
1043
:require_stacking: If True, non-stackable formats will be upgraded
1044
to similar stackable formats.
1045
:returns: a BzrDirFormat with all component formats either set
1046
appropriately or set to None if that component should not be
1049
format, repository = self._cloning_metadir()
1050
if format._workingtree_format is None:
1051
if repository is None:
1053
tree_format = repository._format._matchingbzrdir.workingtree_format
1054
format.workingtree_format = tree_format.__class__()
1055
if require_stacking:
1056
format.require_stacking()
1059
def checkout_metadir(self):
1060
return self.cloning_metadir()
1062
def sprout(self, url, revision_id=None, force_new_repo=False,
1063
recurse='down', possible_transports=None,
1064
accelerator_tree=None, hardlink=False, stacked=False,
1065
source_branch=None, create_tree_if_local=True):
1066
"""Create a copy of this bzrdir prepared for use as a new line of
1069
If url's last component does not exist, it will be created.
1071
Attributes related to the identity of the source branch like
1072
branch nickname will be cleaned, a working tree is created
1073
whether one existed before or not; and a local branch is always
1076
if revision_id is not None, then the clone operation may tune
1077
itself to download less data.
1078
:param accelerator_tree: A tree which can be used for retrieving file
1079
contents more quickly than the revision tree, i.e. a workingtree.
1080
The revision tree will be used for cases where accelerator_tree's
1081
content is different.
1082
:param hardlink: If true, hard-link files from accelerator_tree,
1084
:param stacked: If true, create a stacked branch referring to the
1085
location of this control directory.
1086
:param create_tree_if_local: If true, a working-tree will be created
1087
when working locally.
1089
target_transport = get_transport(url, possible_transports)
1090
target_transport.ensure_base()
1091
cloning_format = self.cloning_metadir(stacked)
1092
# Create/update the result branch
1093
result = cloning_format.initialize_on_transport(target_transport)
1094
# if a stacked branch wasn't requested, we don't create one
1095
# even if the origin was stacked
1096
stacked_branch_url = None
1097
if source_branch is not None:
1099
stacked_branch_url = self.root_transport.base
1100
source_repository = source_branch.repository
1103
source_branch = self.open_branch()
1104
source_repository = source_branch.repository
1106
stacked_branch_url = self.root_transport.base
1107
except errors.NotBranchError:
1108
source_branch = None
1110
source_repository = self.open_repository()
1111
except errors.NoRepositoryPresent:
1112
source_repository = None
1113
repository_policy = result.determine_repository_policy(
1114
force_new_repo, stacked_branch_url, require_stacking=stacked)
1115
result_repo = repository_policy.acquire_repository()
1116
if source_repository is not None:
1117
# Fetch while stacked to prevent unstacked fetch from
1119
result_repo.fetch(source_repository, revision_id=revision_id)
1121
if source_branch is None:
1122
# this is for sprouting a bzrdir without a branch; is that
1124
# Not especially, but it's part of the contract.
1125
result_branch = result.create_branch()
1127
# Force NULL revision to avoid using repository before stacking
1129
result_branch = source_branch.sprout(
1130
result, revision_id=_mod_revision.NULL_REVISION)
1131
parent_location = result_branch.get_parent()
1132
mutter("created new branch %r" % (result_branch,))
1133
repository_policy.configure_branch(result_branch)
1134
if source_branch is not None:
1135
source_branch.copy_content_into(result_branch, revision_id)
1136
# Override copy_content_into
1137
result_branch.set_parent(parent_location)
1139
# Create/update the result working tree
1140
if (create_tree_if_local and
1141
isinstance(target_transport, local.LocalTransport) and
1142
(result_repo is None or result_repo.make_working_trees())):
1143
wt = result.create_workingtree(accelerator_tree=accelerator_tree,
1147
if wt.path2id('') is None:
1149
wt.set_root_id(self.open_workingtree.get_root_id())
1150
except errors.NoWorkingTree:
1156
if recurse == 'down':
1158
basis = wt.basis_tree()
1160
subtrees = basis.iter_references()
1161
elif result_branch is not None:
1162
basis = result_branch.basis_tree()
1164
subtrees = basis.iter_references()
1165
elif source_branch is not None:
1166
basis = source_branch.basis_tree()
1168
subtrees = basis.iter_references()
1173
for path, file_id in subtrees:
1174
target = urlutils.join(url, urlutils.escape(path))
1175
sublocation = source_branch.reference_parent(file_id, path)
1176
sublocation.bzrdir.sprout(target,
1177
basis.get_reference_revision(file_id, path),
1178
force_new_repo=force_new_repo, recurse=recurse,
1181
if basis is not None:
1186
class BzrDirPreSplitOut(BzrDir):
1187
"""A common class for the all-in-one formats."""
1189
def __init__(self, _transport, _format):
1190
"""See BzrDir.__init__."""
1191
super(BzrDirPreSplitOut, self).__init__(_transport, _format)
1192
self._control_files = lockable_files.LockableFiles(
1193
self.get_branch_transport(None),
1194
self._format._lock_file_name,
1195
self._format._lock_class)
1197
def break_lock(self):
1198
"""Pre-splitout bzrdirs do not suffer from stale locks."""
1199
raise NotImplementedError(self.break_lock)
1201
def cloning_metadir(self, require_stacking=False):
1202
"""Produce a metadir suitable for cloning with."""
1203
if require_stacking:
1204
return format_registry.make_bzrdir('1.6')
1205
return self._format.__class__()
1207
def clone(self, url, revision_id=None, force_new_repo=False,
1208
preserve_stacking=False):
1209
"""See BzrDir.clone().
1211
force_new_repo has no effect, since this family of formats always
1212
require a new repository.
1213
preserve_stacking has no effect, since no source branch using this
1214
family of formats can be stacked, so there is no stacking to preserve.
1216
self._make_tail(url)
1217
result = self._format._initialize_for_clone(url)
1218
self.open_repository().clone(result, revision_id=revision_id)
1219
from_branch = self.open_branch()
1220
from_branch.clone(result, revision_id=revision_id)
1222
tree = self.open_workingtree()
1223
except errors.NotLocalUrl:
1224
# make a new one, this format always has to have one.
1225
result._init_workingtree()
1230
def create_branch(self):
1231
"""See BzrDir.create_branch."""
1232
return self._format.get_branch_format().initialize(self)
1234
def destroy_branch(self):
1235
"""See BzrDir.destroy_branch."""
1236
raise errors.UnsupportedOperation(self.destroy_branch, self)
1238
def create_repository(self, shared=False):
1239
"""See BzrDir.create_repository."""
1241
raise errors.IncompatibleFormat('shared repository', self._format)
1242
return self.open_repository()
1244
def destroy_repository(self):
1245
"""See BzrDir.destroy_repository."""
1246
raise errors.UnsupportedOperation(self.destroy_repository, self)
1248
def create_workingtree(self, revision_id=None, from_branch=None,
1249
accelerator_tree=None, hardlink=False):
1250
"""See BzrDir.create_workingtree."""
1251
# The workingtree is sometimes created when the bzrdir is created,
1252
# but not when cloning.
1254
# this looks buggy but is not -really-
1255
# because this format creates the workingtree when the bzrdir is
1257
# clone and sprout will have set the revision_id
1258
# and that will have set it for us, its only
1259
# specific uses of create_workingtree in isolation
1260
# that can do wonky stuff here, and that only
1261
# happens for creating checkouts, which cannot be
1262
# done on this format anyway. So - acceptable wart.
1264
result = self.open_workingtree(recommend_upgrade=False)
1265
except errors.NoSuchFile:
1266
result = self._init_workingtree()
1267
if revision_id is not None:
1268
if revision_id == _mod_revision.NULL_REVISION:
1269
result.set_parent_ids([])
1271
result.set_parent_ids([revision_id])
1274
def _init_workingtree(self):
1275
from bzrlib.workingtree import WorkingTreeFormat2
1277
return WorkingTreeFormat2().initialize(self)
1278
except errors.NotLocalUrl:
1279
# Even though we can't access the working tree, we need to
1280
# create its control files.
1281
return WorkingTreeFormat2()._stub_initialize_on_transport(
1282
self.transport, self._control_files._file_mode)
1284
def destroy_workingtree(self):
1285
"""See BzrDir.destroy_workingtree."""
1286
raise errors.UnsupportedOperation(self.destroy_workingtree, self)
1288
def destroy_workingtree_metadata(self):
1289
"""See BzrDir.destroy_workingtree_metadata."""
1290
raise errors.UnsupportedOperation(self.destroy_workingtree_metadata,
1293
def get_branch_transport(self, branch_format):
1294
"""See BzrDir.get_branch_transport()."""
1295
if branch_format is None:
1296
return self.transport
1298
branch_format.get_format_string()
1299
except NotImplementedError:
1300
return self.transport
1301
raise errors.IncompatibleFormat(branch_format, self._format)
1303
def get_repository_transport(self, repository_format):
1304
"""See BzrDir.get_repository_transport()."""
1305
if repository_format is None:
1306
return self.transport
1308
repository_format.get_format_string()
1309
except NotImplementedError:
1310
return self.transport
1311
raise errors.IncompatibleFormat(repository_format, self._format)
1313
def get_workingtree_transport(self, workingtree_format):
1314
"""See BzrDir.get_workingtree_transport()."""
1315
if workingtree_format is None:
1316
return self.transport
1318
workingtree_format.get_format_string()
1319
except NotImplementedError:
1320
return self.transport
1321
raise errors.IncompatibleFormat(workingtree_format, self._format)
1323
def needs_format_conversion(self, format=None):
1324
"""See BzrDir.needs_format_conversion()."""
1325
# if the format is not the same as the system default,
1326
# an upgrade is needed.
1328
symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
1329
% 'needs_format_conversion(format=None)')
1330
format = BzrDirFormat.get_default_format()
1331
return not isinstance(self._format, format.__class__)
1333
def open_branch(self, unsupported=False):
1334
"""See BzrDir.open_branch."""
1335
from bzrlib.branch import BzrBranchFormat4
1336
format = BzrBranchFormat4()
1337
self._check_supported(format, unsupported)
1338
return format.open(self, _found=True)
1340
def sprout(self, url, revision_id=None, force_new_repo=False,
1341
possible_transports=None, accelerator_tree=None,
1342
hardlink=False, stacked=False, create_tree_if_local=True):
1343
"""See BzrDir.sprout()."""
1345
raise errors.UnstackableBranchFormat(
1346
self._format, self.root_transport.base)
1347
if not create_tree_if_local:
1348
raise errors.MustHaveWorkingTree(
1349
self._format, self.root_transport.base)
1350
from bzrlib.workingtree import WorkingTreeFormat2
1351
self._make_tail(url)
1352
result = self._format._initialize_for_clone(url)
1354
self.open_repository().clone(result, revision_id=revision_id)
1355
except errors.NoRepositoryPresent:
1358
self.open_branch().sprout(result, revision_id=revision_id)
1359
except errors.NotBranchError:
1362
# we always want a working tree
1363
WorkingTreeFormat2().initialize(result,
1364
accelerator_tree=accelerator_tree,
1369
class BzrDir4(BzrDirPreSplitOut):
1370
"""A .bzr version 4 control object.
1372
This is a deprecated format and may be removed after sept 2006.
1375
def create_repository(self, shared=False):
1376
"""See BzrDir.create_repository."""
1377
return self._format.repository_format.initialize(self, shared)
1379
def needs_format_conversion(self, format=None):
1380
"""Format 4 dirs are always in need of conversion."""
1382
symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
1383
% 'needs_format_conversion(format=None)')
1386
def open_repository(self):
1387
"""See BzrDir.open_repository."""
1388
from bzrlib.repofmt.weaverepo import RepositoryFormat4
1389
return RepositoryFormat4().open(self, _found=True)
1392
class BzrDir5(BzrDirPreSplitOut):
1393
"""A .bzr version 5 control object.
1395
This is a deprecated format and may be removed after sept 2006.
1398
def open_repository(self):
1399
"""See BzrDir.open_repository."""
1400
from bzrlib.repofmt.weaverepo import RepositoryFormat5
1401
return RepositoryFormat5().open(self, _found=True)
1403
def open_workingtree(self, _unsupported=False,
1404
recommend_upgrade=True):
1405
"""See BzrDir.create_workingtree."""
1406
from bzrlib.workingtree import WorkingTreeFormat2
1407
wt_format = WorkingTreeFormat2()
1408
# we don't warn here about upgrades; that ought to be handled for the
1410
return wt_format.open(self, _found=True)
1413
class BzrDir6(BzrDirPreSplitOut):
1414
"""A .bzr version 6 control object.
1416
This is a deprecated format and may be removed after sept 2006.
1419
def open_repository(self):
1420
"""See BzrDir.open_repository."""
1421
from bzrlib.repofmt.weaverepo import RepositoryFormat6
1422
return RepositoryFormat6().open(self, _found=True)
1424
def open_workingtree(self, _unsupported=False,
1425
recommend_upgrade=True):
1426
"""See BzrDir.create_workingtree."""
1427
# we don't warn here about upgrades; that ought to be handled for the
1429
from bzrlib.workingtree import WorkingTreeFormat2
1430
return WorkingTreeFormat2().open(self, _found=True)
1433
class BzrDirMeta1(BzrDir):
1434
"""A .bzr meta version 1 control object.
1436
This is the first control object where the
1437
individual aspects are really split out: there are separate repository,
1438
workingtree and branch subdirectories and any subset of the three can be
1439
present within a BzrDir.
1442
def can_convert_format(self):
1443
"""See BzrDir.can_convert_format()."""
1446
def create_branch(self):
1447
"""See BzrDir.create_branch."""
1448
return self._format.get_branch_format().initialize(self)
1450
def destroy_branch(self):
1451
"""See BzrDir.create_branch."""
1452
self.transport.delete_tree('branch')
1454
def create_repository(self, shared=False):
1455
"""See BzrDir.create_repository."""
1456
return self._format.repository_format.initialize(self, shared)
1458
def destroy_repository(self):
1459
"""See BzrDir.destroy_repository."""
1460
self.transport.delete_tree('repository')
1462
def create_workingtree(self, revision_id=None, from_branch=None,
1463
accelerator_tree=None, hardlink=False):
1464
"""See BzrDir.create_workingtree."""
1465
return self._format.workingtree_format.initialize(
1466
self, revision_id, from_branch=from_branch,
1467
accelerator_tree=accelerator_tree, hardlink=hardlink)
1469
def destroy_workingtree(self):
1470
"""See BzrDir.destroy_workingtree."""
1471
wt = self.open_workingtree(recommend_upgrade=False)
1472
repository = wt.branch.repository
1473
empty = repository.revision_tree(_mod_revision.NULL_REVISION)
1474
wt.revert(old_tree=empty)
1475
self.destroy_workingtree_metadata()
1477
def destroy_workingtree_metadata(self):
1478
self.transport.delete_tree('checkout')
1480
def find_branch_format(self):
1481
"""Find the branch 'format' for this bzrdir.
1483
This might be a synthetic object for e.g. RemoteBranch and SVN.
1485
from bzrlib.branch import BranchFormat
1486
return BranchFormat.find_format(self)
1488
def _get_mkdir_mode(self):
1489
"""Figure out the mode to use when creating a bzrdir subdir."""
1490
temp_control = lockable_files.LockableFiles(self.transport, '',
1491
lockable_files.TransportLock)
1492
return temp_control._dir_mode
1494
def get_branch_reference(self):
1495
"""See BzrDir.get_branch_reference()."""
1496
from bzrlib.branch import BranchFormat
1497
format = BranchFormat.find_format(self)
1498
return format.get_reference(self)
1500
def get_branch_transport(self, branch_format):
1501
"""See BzrDir.get_branch_transport()."""
1502
if branch_format is None:
1503
return self.transport.clone('branch')
1505
branch_format.get_format_string()
1506
except NotImplementedError:
1507
raise errors.IncompatibleFormat(branch_format, self._format)
1509
self.transport.mkdir('branch', mode=self._get_mkdir_mode())
1510
except errors.FileExists:
1512
return self.transport.clone('branch')
1514
def get_repository_transport(self, repository_format):
1515
"""See BzrDir.get_repository_transport()."""
1516
if repository_format is None:
1517
return self.transport.clone('repository')
1519
repository_format.get_format_string()
1520
except NotImplementedError:
1521
raise errors.IncompatibleFormat(repository_format, self._format)
1523
self.transport.mkdir('repository', mode=self._get_mkdir_mode())
1524
except errors.FileExists:
1526
return self.transport.clone('repository')
1528
def get_workingtree_transport(self, workingtree_format):
1529
"""See BzrDir.get_workingtree_transport()."""
1530
if workingtree_format is None:
1531
return self.transport.clone('checkout')
1533
workingtree_format.get_format_string()
1534
except NotImplementedError:
1535
raise errors.IncompatibleFormat(workingtree_format, self._format)
1537
self.transport.mkdir('checkout', mode=self._get_mkdir_mode())
1538
except errors.FileExists:
1540
return self.transport.clone('checkout')
1542
def needs_format_conversion(self, format=None):
1543
"""See BzrDir.needs_format_conversion()."""
1545
symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
1546
% 'needs_format_conversion(format=None)')
1548
format = BzrDirFormat.get_default_format()
1549
if not isinstance(self._format, format.__class__):
1550
# it is not a meta dir format, conversion is needed.
1552
# we might want to push this down to the repository?
1554
if not isinstance(self.open_repository()._format,
1555
format.repository_format.__class__):
1556
# the repository needs an upgrade.
1558
except errors.NoRepositoryPresent:
1561
if not isinstance(self.open_branch()._format,
1562
format.get_branch_format().__class__):
1563
# the branch needs an upgrade.
1565
except errors.NotBranchError:
1568
my_wt = self.open_workingtree(recommend_upgrade=False)
1569
if not isinstance(my_wt._format,
1570
format.workingtree_format.__class__):
1571
# the workingtree needs an upgrade.
1573
except (errors.NoWorkingTree, errors.NotLocalUrl):
1577
def open_branch(self, unsupported=False):
1578
"""See BzrDir.open_branch."""
1579
format = self.find_branch_format()
1580
self._check_supported(format, unsupported)
1581
return format.open(self, _found=True)
1583
def open_repository(self, unsupported=False):
1584
"""See BzrDir.open_repository."""
1585
from bzrlib.repository import RepositoryFormat
1586
format = RepositoryFormat.find_format(self)
1587
self._check_supported(format, unsupported)
1588
return format.open(self, _found=True)
1590
def open_workingtree(self, unsupported=False,
1591
recommend_upgrade=True):
1592
"""See BzrDir.open_workingtree."""
1593
from bzrlib.workingtree import WorkingTreeFormat
1594
format = WorkingTreeFormat.find_format(self)
1595
self._check_supported(format, unsupported,
1597
basedir=self.root_transport.base)
1598
return format.open(self, _found=True)
1600
def _get_config(self):
1601
return config.BzrDirConfig(self.transport)
1604
class BzrDirFormat(object):
1605
"""An encapsulation of the initialization and open routines for a format.
1607
Formats provide three things:
1608
* An initialization routine,
1612
Formats are placed in a dict by their format string for reference
1613
during bzrdir opening. These should be subclasses of BzrDirFormat
1616
Once a format is deprecated, just deprecate the initialize and open
1617
methods on the format class. Do not deprecate the object, as the
1618
object will be created every system load.
1621
_default_format = None
1622
"""The default format used for new .bzr dirs."""
1625
"""The known formats."""
1627
_control_formats = []
1628
"""The registered control formats - .bzr, ....
1630
This is a list of BzrDirFormat objects.
1633
_control_server_formats = []
1634
"""The registered control server formats, e.g. RemoteBzrDirs.
1636
This is a list of BzrDirFormat objects.
1639
_lock_file_name = 'branch-lock'
1641
# _lock_class must be set in subclasses to the lock type, typ.
1642
# TransportLock or LockDir
1645
def find_format(klass, transport, _server_formats=True):
1646
"""Return the format present at transport."""
1648
formats = klass._control_server_formats + klass._control_formats
1650
formats = klass._control_formats
1651
for format in formats:
1653
return format.probe_transport(transport)
1654
except errors.NotBranchError:
1655
# this format does not find a control dir here.
1657
raise errors.NotBranchError(path=transport.base)
1660
def probe_transport(klass, transport):
1661
"""Return the .bzrdir style format present in a directory."""
1663
format_string = transport.get(".bzr/branch-format").read()
1664
except errors.NoSuchFile:
1665
raise errors.NotBranchError(path=transport.base)
1668
return klass._formats[format_string]
1670
raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
1673
def get_default_format(klass):
1674
"""Return the current default format."""
1675
return klass._default_format
1677
def get_format_string(self):
1678
"""Return the ASCII format string that identifies this format."""
1679
raise NotImplementedError(self.get_format_string)
1681
def get_format_description(self):
1682
"""Return the short description for this format."""
1683
raise NotImplementedError(self.get_format_description)
1685
def get_converter(self, format=None):
1686
"""Return the converter to use to convert bzrdirs needing converts.
1688
This returns a bzrlib.bzrdir.Converter object.
1690
This should return the best upgrader to step this format towards the
1691
current default format. In the case of plugins we can/should provide
1692
some means for them to extend the range of returnable converters.
1694
:param format: Optional format to override the default format of the
1697
raise NotImplementedError(self.get_converter)
1699
def initialize(self, url, possible_transports=None):
1700
"""Create a bzr control dir at this url and return an opened copy.
1702
Subclasses should typically override initialize_on_transport
1703
instead of this method.
1705
return self.initialize_on_transport(get_transport(url,
1706
possible_transports))
1708
def initialize_on_transport(self, transport):
1709
"""Initialize a new bzrdir in the base directory of a Transport."""
1711
# can we hand off the request to the smart server rather than using
1713
client_medium = transport.get_smart_medium()
1714
except errors.NoSmartMedium:
1715
return self._initialize_on_transport_vfs(transport)
1717
# Current RPC's only know how to create bzr metadir1 instances, so
1718
# we still delegate to vfs methods if the requested format is not a
1720
if type(self) != BzrDirMetaFormat1:
1721
return self._initialize_on_transport_vfs(transport)
1722
remote_format = RemoteBzrDirFormat()
1723
self._supply_sub_formats_to(remote_format)
1724
return remote_format.initialize_on_transport(transport)
1726
def _initialize_on_transport_vfs(self, transport):
1727
"""Initialize a new bzrdir using VFS calls.
1729
:param transport: The transport to create the .bzr directory in.
1732
# Since we are creating a .bzr directory, inherit the
1733
# mode from the root directory
1734
temp_control = lockable_files.LockableFiles(transport,
1735
'', lockable_files.TransportLock)
1736
temp_control._transport.mkdir('.bzr',
1737
# FIXME: RBC 20060121 don't peek under
1739
mode=temp_control._dir_mode)
1740
if sys.platform == 'win32' and isinstance(transport, local.LocalTransport):
1741
win32utils.set_file_attr_hidden(transport._abspath('.bzr'))
1742
file_mode = temp_control._file_mode
1744
bzrdir_transport = transport.clone('.bzr')
1745
utf8_files = [('README',
1746
"This is a Bazaar control directory.\n"
1747
"Do not change any files in this directory.\n"
1748
"See http://bazaar-vcs.org/ for more information about Bazaar.\n"),
1749
('branch-format', self.get_format_string()),
1751
# NB: no need to escape relative paths that are url safe.
1752
control_files = lockable_files.LockableFiles(bzrdir_transport,
1753
self._lock_file_name, self._lock_class)
1754
control_files.create_lock()
1755
control_files.lock_write()
1757
for (filename, content) in utf8_files:
1758
bzrdir_transport.put_bytes(filename, content,
1761
control_files.unlock()
1762
return self.open(transport, _found=True)
1764
def is_supported(self):
1765
"""Is this format supported?
1767
Supported formats must be initializable and openable.
1768
Unsupported formats may not support initialization or committing or
1769
some other features depending on the reason for not being supported.
1773
def same_model(self, target_format):
1774
return (self.repository_format.rich_root_data ==
1775
target_format.rich_root_data)
1778
def known_formats(klass):
1779
"""Return all the known formats.
1781
Concrete formats should override _known_formats.
1783
# There is double indirection here to make sure that control
1784
# formats used by more than one dir format will only be probed
1785
# once. This can otherwise be quite expensive for remote connections.
1787
for format in klass._control_formats:
1788
result.update(format._known_formats())
1792
def _known_formats(klass):
1793
"""Return the known format instances for this control format."""
1794
return set(klass._formats.values())
1796
def open(self, transport, _found=False):
1797
"""Return an instance of this format for the dir transport points at.
1799
_found is a private parameter, do not use it.
1802
found_format = BzrDirFormat.find_format(transport)
1803
if not isinstance(found_format, self.__class__):
1804
raise AssertionError("%s was asked to open %s, but it seems to need "
1806
% (self, transport, found_format))
1807
# Allow subclasses - use the found format.
1808
self._supply_sub_formats_to(found_format)
1809
return found_format._open(transport)
1810
return self._open(transport)
1812
def _open(self, transport):
1813
"""Template method helper for opening BzrDirectories.
1815
This performs the actual open and any additional logic or parameter
1818
raise NotImplementedError(self._open)
1821
def register_format(klass, format):
1822
klass._formats[format.get_format_string()] = format
1825
def register_control_format(klass, format):
1826
"""Register a format that does not use '.bzr' for its control dir.
1828
TODO: This should be pulled up into a 'ControlDirFormat' base class
1829
which BzrDirFormat can inherit from, and renamed to register_format
1830
there. It has been done without that for now for simplicity of
1833
klass._control_formats.append(format)
1836
def register_control_server_format(klass, format):
1837
"""Register a control format for client-server environments.
1839
These formats will be tried before ones registered with
1840
register_control_format. This gives implementations that decide to the
1841
chance to grab it before anything looks at the contents of the format
1844
klass._control_server_formats.append(format)
1847
def _set_default_format(klass, format):
1848
"""Set default format (for testing behavior of defaults only)"""
1849
klass._default_format = format
1853
return self.get_format_description().rstrip()
1855
def _supply_sub_formats_to(self, other_format):
1856
"""Give other_format the same values for sub formats as this has.
1858
This method is expected to be used when parameterising a
1859
RemoteBzrDirFormat instance with the parameters from a
1860
BzrDirMetaFormat1 instance.
1862
:param other_format: other_format is a format which should be
1863
compatible with whatever sub formats are supported by self.
1868
def unregister_format(klass, format):
1869
del klass._formats[format.get_format_string()]
1872
def unregister_control_format(klass, format):
1873
klass._control_formats.remove(format)
1876
class BzrDirFormat4(BzrDirFormat):
1877
"""Bzr dir format 4.
1879
This format is a combined format for working tree, branch and repository.
1881
- Format 1 working trees [always]
1882
- Format 4 branches [always]
1883
- Format 4 repositories [always]
1885
This format is deprecated: it indexes texts using a text it which is
1886
removed in format 5; write support for this format has been removed.
1889
_lock_class = lockable_files.TransportLock
1891
def get_format_string(self):
1892
"""See BzrDirFormat.get_format_string()."""
1893
return "Bazaar-NG branch, format 0.0.4\n"
1895
def get_format_description(self):
1896
"""See BzrDirFormat.get_format_description()."""
1897
return "All-in-one format 4"
1899
def get_converter(self, format=None):
1900
"""See BzrDirFormat.get_converter()."""
1901
# there is one and only one upgrade path here.
1902
return ConvertBzrDir4To5()
1904
def initialize_on_transport(self, transport):
1905
"""Format 4 branches cannot be created."""
1906
raise errors.UninitializableFormat(self)
1908
def is_supported(self):
1909
"""Format 4 is not supported.
1911
It is not supported because the model changed from 4 to 5 and the
1912
conversion logic is expensive - so doing it on the fly was not
1917
def _open(self, transport):
1918
"""See BzrDirFormat._open."""
1919
return BzrDir4(transport, self)
1921
def __return_repository_format(self):
1922
"""Circular import protection."""
1923
from bzrlib.repofmt.weaverepo import RepositoryFormat4
1924
return RepositoryFormat4()
1925
repository_format = property(__return_repository_format)
1928
class BzrDirFormat5(BzrDirFormat):
1929
"""Bzr control format 5.
1931
This format is a combined format for working tree, branch and repository.
1933
- Format 2 working trees [always]
1934
- Format 4 branches [always]
1935
- Format 5 repositories [always]
1936
Unhashed stores in the repository.
1939
_lock_class = lockable_files.TransportLock
1941
def get_format_string(self):
1942
"""See BzrDirFormat.get_format_string()."""
1943
return "Bazaar-NG branch, format 5\n"
1945
def get_branch_format(self):
1946
from bzrlib import branch
1947
return branch.BzrBranchFormat4()
1949
def get_format_description(self):
1950
"""See BzrDirFormat.get_format_description()."""
1951
return "All-in-one format 5"
1953
def get_converter(self, format=None):
1954
"""See BzrDirFormat.get_converter()."""
1955
# there is one and only one upgrade path here.
1956
return ConvertBzrDir5To6()
1958
def _initialize_for_clone(self, url):
1959
return self.initialize_on_transport(get_transport(url), _cloning=True)
1961
def initialize_on_transport(self, transport, _cloning=False):
1962
"""Format 5 dirs always have working tree, branch and repository.
1964
Except when they are being cloned.
1966
from bzrlib.branch import BzrBranchFormat4
1967
from bzrlib.repofmt.weaverepo import RepositoryFormat5
1968
result = (super(BzrDirFormat5, self).initialize_on_transport(transport))
1969
RepositoryFormat5().initialize(result, _internal=True)
1971
branch = BzrBranchFormat4().initialize(result)
1972
result._init_workingtree()
1975
def _open(self, transport):
1976
"""See BzrDirFormat._open."""
1977
return BzrDir5(transport, self)
1979
def __return_repository_format(self):
1980
"""Circular import protection."""
1981
from bzrlib.repofmt.weaverepo import RepositoryFormat5
1982
return RepositoryFormat5()
1983
repository_format = property(__return_repository_format)
1986
class BzrDirFormat6(BzrDirFormat):
1987
"""Bzr control format 6.
1989
This format is a combined format for working tree, branch and repository.
1991
- Format 2 working trees [always]
1992
- Format 4 branches [always]
1993
- Format 6 repositories [always]
1996
_lock_class = lockable_files.TransportLock
1998
def get_format_string(self):
1999
"""See BzrDirFormat.get_format_string()."""
2000
return "Bazaar-NG branch, format 6\n"
2002
def get_format_description(self):
2003
"""See BzrDirFormat.get_format_description()."""
2004
return "All-in-one format 6"
2006
def get_branch_format(self):
2007
from bzrlib import branch
2008
return branch.BzrBranchFormat4()
2010
def get_converter(self, format=None):
2011
"""See BzrDirFormat.get_converter()."""
2012
# there is one and only one upgrade path here.
2013
return ConvertBzrDir6ToMeta()
2015
def _initialize_for_clone(self, url):
2016
return self.initialize_on_transport(get_transport(url), _cloning=True)
2018
def initialize_on_transport(self, transport, _cloning=False):
2019
"""Format 6 dirs always have working tree, branch and repository.
2021
Except when they are being cloned.
2023
from bzrlib.branch import BzrBranchFormat4
2024
from bzrlib.repofmt.weaverepo import RepositoryFormat6
2025
result = super(BzrDirFormat6, self).initialize_on_transport(transport)
2026
RepositoryFormat6().initialize(result, _internal=True)
2028
branch = BzrBranchFormat4().initialize(result)
2029
result._init_workingtree()
2032
def _open(self, transport):
2033
"""See BzrDirFormat._open."""
2034
return BzrDir6(transport, self)
2036
def __return_repository_format(self):
2037
"""Circular import protection."""
2038
from bzrlib.repofmt.weaverepo import RepositoryFormat6
2039
return RepositoryFormat6()
2040
repository_format = property(__return_repository_format)
2043
class BzrDirMetaFormat1(BzrDirFormat):
2044
"""Bzr meta control format 1
2046
This is the first format with split out working tree, branch and repository
2049
- Format 3 working trees [optional]
2050
- Format 5 branches [optional]
2051
- Format 7 repositories [optional]
2054
_lock_class = lockdir.LockDir
2057
self._workingtree_format = None
2058
self._branch_format = None
2060
def __eq__(self, other):
2061
if other.__class__ is not self.__class__:
2063
if other.repository_format != self.repository_format:
2065
if other.workingtree_format != self.workingtree_format:
2069
def __ne__(self, other):
2070
return not self == other
2072
def get_branch_format(self):
2073
if self._branch_format is None:
2074
from bzrlib.branch import BranchFormat
2075
self._branch_format = BranchFormat.get_default_format()
2076
return self._branch_format
2078
def set_branch_format(self, format):
2079
self._branch_format = format
2081
def require_stacking(self):
2082
if not self.get_branch_format().supports_stacking():
2083
# We need to make a stacked branch, but the default format for the
2084
# target doesn't support stacking. So force a branch that *can*
2086
from bzrlib.branch import BzrBranchFormat7
2087
branch_format = BzrBranchFormat7()
2088
self.set_branch_format(branch_format)
2089
mutter("using %r for stacking" % (branch_format,))
2090
from bzrlib.repofmt import pack_repo
2091
if self.repository_format.rich_root_data:
2092
bzrdir_format_name = '1.6.1-rich-root'
2093
repo_format = pack_repo.RepositoryFormatKnitPack5RichRoot()
2095
bzrdir_format_name = '1.6'
2096
repo_format = pack_repo.RepositoryFormatKnitPack5()
2097
note('Source format does not support stacking, using format:'
2099
bzrdir_format_name, repo_format.get_format_description())
2100
self.repository_format = repo_format
2102
def get_converter(self, format=None):
2103
"""See BzrDirFormat.get_converter()."""
2105
format = BzrDirFormat.get_default_format()
2106
if not isinstance(self, format.__class__):
2107
# converting away from metadir is not implemented
2108
raise NotImplementedError(self.get_converter)
2109
return ConvertMetaToMeta(format)
2111
def get_format_string(self):
2112
"""See BzrDirFormat.get_format_string()."""
2113
return "Bazaar-NG meta directory, format 1\n"
2115
def get_format_description(self):
2116
"""See BzrDirFormat.get_format_description()."""
2117
return "Meta directory format 1"
2119
def _open(self, transport):
2120
"""See BzrDirFormat._open."""
2121
return BzrDirMeta1(transport, self)
2123
def __return_repository_format(self):
2124
"""Circular import protection."""
2125
if getattr(self, '_repository_format', None):
2126
return self._repository_format
2127
from bzrlib.repository import RepositoryFormat
2128
return RepositoryFormat.get_default_format()
2130
def _set_repository_format(self, value):
2131
"""Allow changing the repository format for metadir formats."""
2132
self._repository_format = value
2134
repository_format = property(__return_repository_format,
2135
_set_repository_format)
2137
def _supply_sub_formats_to(self, other_format):
2138
"""Give other_format the same values for sub formats as this has.
2140
This method is expected to be used when parameterising a
2141
RemoteBzrDirFormat instance with the parameters from a
2142
BzrDirMetaFormat1 instance.
2144
:param other_format: other_format is a format which should be
2145
compatible with whatever sub formats are supported by self.
2148
if getattr(self, '_repository_format', None) is not None:
2149
other_format.repository_format = self.repository_format
2150
if self._branch_format is not None:
2151
other_format._branch_format = self._branch_format
2152
if self._workingtree_format is not None:
2153
other_format.workingtree_format = self.workingtree_format
2155
def __get_workingtree_format(self):
2156
if self._workingtree_format is None:
2157
from bzrlib.workingtree import WorkingTreeFormat
2158
self._workingtree_format = WorkingTreeFormat.get_default_format()
2159
return self._workingtree_format
2161
def __set_workingtree_format(self, wt_format):
2162
self._workingtree_format = wt_format
2164
workingtree_format = property(__get_workingtree_format,
2165
__set_workingtree_format)
2168
# Register bzr control format
2169
BzrDirFormat.register_control_format(BzrDirFormat)
2171
# Register bzr formats
2172
BzrDirFormat.register_format(BzrDirFormat4())
2173
BzrDirFormat.register_format(BzrDirFormat5())
2174
BzrDirFormat.register_format(BzrDirFormat6())
2175
__default_format = BzrDirMetaFormat1()
2176
BzrDirFormat.register_format(__default_format)
2177
BzrDirFormat._default_format = __default_format
2180
class Converter(object):
2181
"""Converts a disk format object from one format to another."""
2183
def convert(self, to_convert, pb):
2184
"""Perform the conversion of to_convert, giving feedback via pb.
2186
:param to_convert: The disk object to convert.
2187
:param pb: a progress bar to use for progress information.
2190
def step(self, message):
2191
"""Update the pb by a step."""
2193
self.pb.update(message, self.count, self.total)
2196
class ConvertBzrDir4To5(Converter):
2197
"""Converts format 4 bzr dirs to format 5."""
2200
super(ConvertBzrDir4To5, self).__init__()
2201
self.converted_revs = set()
2202
self.absent_revisions = set()
2206
def convert(self, to_convert, pb):
2207
"""See Converter.convert()."""
2208
self.bzrdir = to_convert
2210
self.pb.note('starting upgrade from format 4 to 5')
2211
if isinstance(self.bzrdir.transport, local.LocalTransport):
2212
self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
2213
self._convert_to_weaves()
2214
return BzrDir.open(self.bzrdir.root_transport.base)
2216
def _convert_to_weaves(self):
2217
self.pb.note('note: upgrade may be faster if all store files are ungzipped first')
2220
stat = self.bzrdir.transport.stat('weaves')
2221
if not S_ISDIR(stat.st_mode):
2222
self.bzrdir.transport.delete('weaves')
2223
self.bzrdir.transport.mkdir('weaves')
2224
except errors.NoSuchFile:
2225
self.bzrdir.transport.mkdir('weaves')
2226
# deliberately not a WeaveFile as we want to build it up slowly.
2227
self.inv_weave = Weave('inventory')
2228
# holds in-memory weaves for all files
2229
self.text_weaves = {}
2230
self.bzrdir.transport.delete('branch-format')
2231
self.branch = self.bzrdir.open_branch()
2232
self._convert_working_inv()
2233
rev_history = self.branch.revision_history()
2234
# to_read is a stack holding the revisions we still need to process;
2235
# appending to it adds new highest-priority revisions
2236
self.known_revisions = set(rev_history)
2237
self.to_read = rev_history[-1:]
2239
rev_id = self.to_read.pop()
2240
if (rev_id not in self.revisions
2241
and rev_id not in self.absent_revisions):
2242
self._load_one_rev(rev_id)
2244
to_import = self._make_order()
2245
for i, rev_id in enumerate(to_import):
2246
self.pb.update('converting revision', i, len(to_import))
2247
self._convert_one_rev(rev_id)
2249
self._write_all_weaves()
2250
self._write_all_revs()
2251
self.pb.note('upgraded to weaves:')
2252
self.pb.note(' %6d revisions and inventories', len(self.revisions))
2253
self.pb.note(' %6d revisions not present', len(self.absent_revisions))
2254
self.pb.note(' %6d texts', self.text_count)
2255
self._cleanup_spare_files_after_format4()
2256
self.branch._transport.put_bytes(
2258
BzrDirFormat5().get_format_string(),
2259
mode=self.bzrdir._get_file_mode())
2261
def _cleanup_spare_files_after_format4(self):
2262
# FIXME working tree upgrade foo.
2263
for n in 'merged-patches', 'pending-merged-patches':
2265
## assert os.path.getsize(p) == 0
2266
self.bzrdir.transport.delete(n)
2267
except errors.NoSuchFile:
2269
self.bzrdir.transport.delete_tree('inventory-store')
2270
self.bzrdir.transport.delete_tree('text-store')
2272
def _convert_working_inv(self):
2273
inv = xml4.serializer_v4.read_inventory(
2274
self.branch._transport.get('inventory'))
2275
new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv, working=True)
2276
self.branch._transport.put_bytes('inventory', new_inv_xml,
2277
mode=self.bzrdir._get_file_mode())
2279
def _write_all_weaves(self):
2280
controlweaves = WeaveStore(self.bzrdir.transport, prefixed=False)
2281
weave_transport = self.bzrdir.transport.clone('weaves')
2282
weaves = WeaveStore(weave_transport, prefixed=False)
2283
transaction = WriteTransaction()
2287
for file_id, file_weave in self.text_weaves.items():
2288
self.pb.update('writing weave', i, len(self.text_weaves))
2289
weaves._put_weave(file_id, file_weave, transaction)
2291
self.pb.update('inventory', 0, 1)
2292
controlweaves._put_weave('inventory', self.inv_weave, transaction)
2293
self.pb.update('inventory', 1, 1)
2297
def _write_all_revs(self):
2298
"""Write all revisions out in new form."""
2299
self.bzrdir.transport.delete_tree('revision-store')
2300
self.bzrdir.transport.mkdir('revision-store')
2301
revision_transport = self.bzrdir.transport.clone('revision-store')
2303
from bzrlib.xml5 import serializer_v5
2304
from bzrlib.repofmt.weaverepo import RevisionTextStore
2305
revision_store = RevisionTextStore(revision_transport,
2306
serializer_v5, False, versionedfile.PrefixMapper(),
2307
lambda:True, lambda:True)
2309
for i, rev_id in enumerate(self.converted_revs):
2310
self.pb.update('write revision', i, len(self.converted_revs))
2311
text = serializer_v5.write_revision_to_string(
2312
self.revisions[rev_id])
2314
revision_store.add_lines(key, None, osutils.split_lines(text))
2318
def _load_one_rev(self, rev_id):
2319
"""Load a revision object into memory.
2321
Any parents not either loaded or abandoned get queued to be
2323
self.pb.update('loading revision',
2324
len(self.revisions),
2325
len(self.known_revisions))
2326
if not self.branch.repository.has_revision(rev_id):
2328
self.pb.note('revision {%s} not present in branch; '
2329
'will be converted as a ghost',
2331
self.absent_revisions.add(rev_id)
2333
rev = self.branch.repository.get_revision(rev_id)
2334
for parent_id in rev.parent_ids:
2335
self.known_revisions.add(parent_id)
2336
self.to_read.append(parent_id)
2337
self.revisions[rev_id] = rev
2339
def _load_old_inventory(self, rev_id):
2340
old_inv_xml = self.branch.repository.inventory_store.get(rev_id).read()
2341
inv = xml4.serializer_v4.read_inventory_from_string(old_inv_xml)
2342
inv.revision_id = rev_id
2343
rev = self.revisions[rev_id]
2346
def _load_updated_inventory(self, rev_id):
2347
inv_xml = self.inv_weave.get_text(rev_id)
2348
inv = xml5.serializer_v5.read_inventory_from_string(inv_xml, rev_id)
2351
def _convert_one_rev(self, rev_id):
2352
"""Convert revision and all referenced objects to new format."""
2353
rev = self.revisions[rev_id]
2354
inv = self._load_old_inventory(rev_id)
2355
present_parents = [p for p in rev.parent_ids
2356
if p not in self.absent_revisions]
2357
self._convert_revision_contents(rev, inv, present_parents)
2358
self._store_new_inv(rev, inv, present_parents)
2359
self.converted_revs.add(rev_id)
2361
def _store_new_inv(self, rev, inv, present_parents):
2362
new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
2363
new_inv_sha1 = sha_string(new_inv_xml)
2364
self.inv_weave.add_lines(rev.revision_id,
2366
new_inv_xml.splitlines(True))
2367
rev.inventory_sha1 = new_inv_sha1
2369
def _convert_revision_contents(self, rev, inv, present_parents):
2370
"""Convert all the files within a revision.
2372
Also upgrade the inventory to refer to the text revision ids."""
2373
rev_id = rev.revision_id
2374
mutter('converting texts of revision {%s}',
2376
parent_invs = map(self._load_updated_inventory, present_parents)
2377
entries = inv.iter_entries()
2379
for path, ie in entries:
2380
self._convert_file_version(rev, ie, parent_invs)
2382
def _convert_file_version(self, rev, ie, parent_invs):
2383
"""Convert one version of one file.
2385
The file needs to be added into the weave if it is a merge
2386
of >=2 parents or if it's changed from its parent.
2388
file_id = ie.file_id
2389
rev_id = rev.revision_id
2390
w = self.text_weaves.get(file_id)
2393
self.text_weaves[file_id] = w
2394
text_changed = False
2395
parent_candiate_entries = ie.parent_candidates(parent_invs)
2396
heads = graph.Graph(self).heads(parent_candiate_entries.keys())
2397
# XXX: Note that this is unordered - and this is tolerable because
2398
# the previous code was also unordered.
2399
previous_entries = dict((head, parent_candiate_entries[head]) for head
2401
self.snapshot_ie(previous_entries, ie, w, rev_id)
2404
@symbol_versioning.deprecated_method(symbol_versioning.one_one)
2405
def get_parents(self, revision_ids):
2406
for revision_id in revision_ids:
2407
yield self.revisions[revision_id].parent_ids
2409
def get_parent_map(self, revision_ids):
2410
"""See graph._StackedParentsProvider.get_parent_map"""
2411
return dict((revision_id, self.revisions[revision_id])
2412
for revision_id in revision_ids
2413
if revision_id in self.revisions)
2415
def snapshot_ie(self, previous_revisions, ie, w, rev_id):
2416
# TODO: convert this logic, which is ~= snapshot to
2417
# a call to:. This needs the path figured out. rather than a work_tree
2418
# a v4 revision_tree can be given, or something that looks enough like
2419
# one to give the file content to the entry if it needs it.
2420
# and we need something that looks like a weave store for snapshot to
2422
#ie.snapshot(rev, PATH, previous_revisions, REVISION_TREE, InMemoryWeaveStore(self.text_weaves))
2423
if len(previous_revisions) == 1:
2424
previous_ie = previous_revisions.values()[0]
2425
if ie._unchanged(previous_ie):
2426
ie.revision = previous_ie.revision
2429
text = self.branch.repository._text_store.get(ie.text_id)
2430
file_lines = text.readlines()
2431
w.add_lines(rev_id, previous_revisions, file_lines)
2432
self.text_count += 1
2434
w.add_lines(rev_id, previous_revisions, [])
2435
ie.revision = rev_id
2437
def _make_order(self):
2438
"""Return a suitable order for importing revisions.
2440
The order must be such that an revision is imported after all
2441
its (present) parents.
2443
todo = set(self.revisions.keys())
2444
done = self.absent_revisions.copy()
2447
# scan through looking for a revision whose parents
2449
for rev_id in sorted(list(todo)):
2450
rev = self.revisions[rev_id]
2451
parent_ids = set(rev.parent_ids)
2452
if parent_ids.issubset(done):
2453
# can take this one now
2454
order.append(rev_id)
2460
class ConvertBzrDir5To6(Converter):
2461
"""Converts format 5 bzr dirs to format 6."""
2463
def convert(self, to_convert, pb):
2464
"""See Converter.convert()."""
2465
self.bzrdir = to_convert
2467
self.pb.note('starting upgrade from format 5 to 6')
2468
self._convert_to_prefixed()
2469
return BzrDir.open(self.bzrdir.root_transport.base)
2471
def _convert_to_prefixed(self):
2472
from bzrlib.store import TransportStore
2473
self.bzrdir.transport.delete('branch-format')
2474
for store_name in ["weaves", "revision-store"]:
2475
self.pb.note("adding prefixes to %s" % store_name)
2476
store_transport = self.bzrdir.transport.clone(store_name)
2477
store = TransportStore(store_transport, prefixed=True)
2478
for urlfilename in store_transport.list_dir('.'):
2479
filename = urlutils.unescape(urlfilename)
2480
if (filename.endswith(".weave") or
2481
filename.endswith(".gz") or
2482
filename.endswith(".sig")):
2483
file_id, suffix = os.path.splitext(filename)
2487
new_name = store._mapper.map((file_id,)) + suffix
2488
# FIXME keep track of the dirs made RBC 20060121
2490
store_transport.move(filename, new_name)
2491
except errors.NoSuchFile: # catches missing dirs strangely enough
2492
store_transport.mkdir(osutils.dirname(new_name))
2493
store_transport.move(filename, new_name)
2494
self.bzrdir.transport.put_bytes(
2496
BzrDirFormat6().get_format_string(),
2497
mode=self.bzrdir._get_file_mode())
2500
class ConvertBzrDir6ToMeta(Converter):
2501
"""Converts format 6 bzr dirs to metadirs."""
2503
def convert(self, to_convert, pb):
2504
"""See Converter.convert()."""
2505
from bzrlib.repofmt.weaverepo import RepositoryFormat7
2506
from bzrlib.branch import BzrBranchFormat5
2507
self.bzrdir = to_convert
2510
self.total = 20 # the steps we know about
2511
self.garbage_inventories = []
2512
self.dir_mode = self.bzrdir._get_dir_mode()
2513
self.file_mode = self.bzrdir._get_file_mode()
2515
self.pb.note('starting upgrade from format 6 to metadir')
2516
self.bzrdir.transport.put_bytes(
2518
"Converting to format 6",
2519
mode=self.file_mode)
2520
# its faster to move specific files around than to open and use the apis...
2521
# first off, nuke ancestry.weave, it was never used.
2523
self.step('Removing ancestry.weave')
2524
self.bzrdir.transport.delete('ancestry.weave')
2525
except errors.NoSuchFile:
2527
# find out whats there
2528
self.step('Finding branch files')
2529
last_revision = self.bzrdir.open_branch().last_revision()
2530
bzrcontents = self.bzrdir.transport.list_dir('.')
2531
for name in bzrcontents:
2532
if name.startswith('basis-inventory.'):
2533
self.garbage_inventories.append(name)
2534
# create new directories for repository, working tree and branch
2535
repository_names = [('inventory.weave', True),
2536
('revision-store', True),
2538
self.step('Upgrading repository ')
2539
self.bzrdir.transport.mkdir('repository', mode=self.dir_mode)
2540
self.make_lock('repository')
2541
# we hard code the formats here because we are converting into
2542
# the meta format. The meta format upgrader can take this to a
2543
# future format within each component.
2544
self.put_format('repository', RepositoryFormat7())
2545
for entry in repository_names:
2546
self.move_entry('repository', entry)
2548
self.step('Upgrading branch ')
2549
self.bzrdir.transport.mkdir('branch', mode=self.dir_mode)
2550
self.make_lock('branch')
2551
self.put_format('branch', BzrBranchFormat5())
2552
branch_files = [('revision-history', True),
2553
('branch-name', True),
2555
for entry in branch_files:
2556
self.move_entry('branch', entry)
2558
checkout_files = [('pending-merges', True),
2559
('inventory', True),
2560
('stat-cache', False)]
2561
# If a mandatory checkout file is not present, the branch does not have
2562
# a functional checkout. Do not create a checkout in the converted
2564
for name, mandatory in checkout_files:
2565
if mandatory and name not in bzrcontents:
2566
has_checkout = False
2570
if not has_checkout:
2571
self.pb.note('No working tree.')
2572
# If some checkout files are there, we may as well get rid of them.
2573
for name, mandatory in checkout_files:
2574
if name in bzrcontents:
2575
self.bzrdir.transport.delete(name)
2577
from bzrlib.workingtree import WorkingTreeFormat3
2578
self.step('Upgrading working tree')
2579
self.bzrdir.transport.mkdir('checkout', mode=self.dir_mode)
2580
self.make_lock('checkout')
2582
'checkout', WorkingTreeFormat3())
2583
self.bzrdir.transport.delete_multi(
2584
self.garbage_inventories, self.pb)
2585
for entry in checkout_files:
2586
self.move_entry('checkout', entry)
2587
if last_revision is not None:
2588
self.bzrdir.transport.put_bytes(
2589
'checkout/last-revision', last_revision)
2590
self.bzrdir.transport.put_bytes(
2592
BzrDirMetaFormat1().get_format_string(),
2593
mode=self.file_mode)
2594
return BzrDir.open(self.bzrdir.root_transport.base)
2596
def make_lock(self, name):
2597
"""Make a lock for the new control dir name."""
2598
self.step('Make %s lock' % name)
2599
ld = lockdir.LockDir(self.bzrdir.transport,
2601
file_modebits=self.file_mode,
2602
dir_modebits=self.dir_mode)
2605
def move_entry(self, new_dir, entry):
2606
"""Move then entry name into new_dir."""
2608
mandatory = entry[1]
2609
self.step('Moving %s' % name)
2611
self.bzrdir.transport.move(name, '%s/%s' % (new_dir, name))
2612
except errors.NoSuchFile:
2616
def put_format(self, dirname, format):
2617
self.bzrdir.transport.put_bytes('%s/format' % dirname,
2618
format.get_format_string(),
2622
class ConvertMetaToMeta(Converter):
2623
"""Converts the components of metadirs."""
2625
def __init__(self, target_format):
2626
"""Create a metadir to metadir converter.
2628
:param target_format: The final metadir format that is desired.
2630
self.target_format = target_format
2632
def convert(self, to_convert, pb):
2633
"""See Converter.convert()."""
2634
self.bzrdir = to_convert
2638
self.step('checking repository format')
2640
repo = self.bzrdir.open_repository()
2641
except errors.NoRepositoryPresent:
2644
if not isinstance(repo._format, self.target_format.repository_format.__class__):
2645
from bzrlib.repository import CopyConverter
2646
self.pb.note('starting repository conversion')
2647
converter = CopyConverter(self.target_format.repository_format)
2648
converter.convert(repo, pb)
2650
branch = self.bzrdir.open_branch()
2651
except errors.NotBranchError:
2654
# TODO: conversions of Branch and Tree should be done by
2655
# InterXFormat lookups/some sort of registry.
2656
# Avoid circular imports
2657
from bzrlib import branch as _mod_branch
2658
old = branch._format.__class__
2659
new = self.target_format.get_branch_format().__class__
2661
if (old == _mod_branch.BzrBranchFormat5 and
2662
new in (_mod_branch.BzrBranchFormat6,
2663
_mod_branch.BzrBranchFormat7)):
2664
branch_converter = _mod_branch.Converter5to6()
2665
elif (old == _mod_branch.BzrBranchFormat6 and
2666
new == _mod_branch.BzrBranchFormat7):
2667
branch_converter = _mod_branch.Converter6to7()
2669
raise errors.BadConversionTarget("No converter", new)
2670
branch_converter.convert(branch)
2671
branch = self.bzrdir.open_branch()
2672
old = branch._format.__class__
2674
tree = self.bzrdir.open_workingtree(recommend_upgrade=False)
2675
except (errors.NoWorkingTree, errors.NotLocalUrl):
2678
# TODO: conversions of Branch and Tree should be done by
2679
# InterXFormat lookups
2680
if (isinstance(tree, workingtree.WorkingTree3) and
2681
not isinstance(tree, workingtree_4.DirStateWorkingTree) and
2682
isinstance(self.target_format.workingtree_format,
2683
workingtree_4.DirStateWorkingTreeFormat)):
2684
workingtree_4.Converter3to4().convert(tree)
2685
if (isinstance(tree, workingtree_4.DirStateWorkingTree) and
2686
not isinstance(tree, workingtree_4.WorkingTree5) and
2687
isinstance(self.target_format.workingtree_format,
2688
workingtree_4.WorkingTreeFormat5)):
2689
workingtree_4.Converter4to5().convert(tree)
2693
# This is not in remote.py because it's small, and needs to be registered.
2694
# Putting it in remote.py creates a circular import problem.
2695
# we can make it a lazy object if the control formats is turned into something
2697
class RemoteBzrDirFormat(BzrDirMetaFormat1):
2698
"""Format representing bzrdirs accessed via a smart server"""
2700
def get_format_description(self):
2701
return 'bzr remote bzrdir'
2703
def get_format_string(self):
2704
raise NotImplementedError(self.get_format_string)
2707
def probe_transport(klass, transport):
2708
"""Return a RemoteBzrDirFormat object if it looks possible."""
2710
medium = transport.get_smart_medium()
2711
except (NotImplementedError, AttributeError,
2712
errors.TransportNotPossible, errors.NoSmartMedium,
2713
errors.SmartProtocolError):
2714
# no smart server, so not a branch for this format type.
2715
raise errors.NotBranchError(path=transport.base)
2717
# Decline to open it if the server doesn't support our required
2718
# version (3) so that the VFS-based transport will do it.
2719
if medium.should_probe():
2721
server_version = medium.protocol_version()
2722
except errors.SmartProtocolError:
2723
# Apparently there's no usable smart server there, even though
2724
# the medium supports the smart protocol.
2725
raise errors.NotBranchError(path=transport.base)
2726
if server_version != '2':
2727
raise errors.NotBranchError(path=transport.base)
2730
def initialize_on_transport(self, transport):
2732
# hand off the request to the smart server
2733
client_medium = transport.get_smart_medium()
2734
except errors.NoSmartMedium:
2735
# TODO: lookup the local format from a server hint.
2736
local_dir_format = BzrDirMetaFormat1()
2737
return local_dir_format.initialize_on_transport(transport)
2738
client = _SmartClient(client_medium)
2739
path = client.remote_path_from_transport(transport)
2740
response = client.call('BzrDirFormat.initialize', path)
2741
if response[0] != 'ok':
2742
raise errors.SmartProtocolError('unexpected response code %s' % (response,))
2743
format = RemoteBzrDirFormat()
2744
self._supply_sub_formats_to(format)
2745
return remote.RemoteBzrDir(transport, format)
2747
def _open(self, transport):
2748
return remote.RemoteBzrDir(transport, self)
2750
def __eq__(self, other):
2751
if not isinstance(other, RemoteBzrDirFormat):
2753
return self.get_format_description() == other.get_format_description()
2755
def __return_repository_format(self):
2756
# Always return a RemoteRepositoryFormat object, but if a specific bzr
2757
# repository format has been asked for, tell the RemoteRepositoryFormat
2758
# that it should use that for init() etc.
2759
result = remote.RemoteRepositoryFormat()
2760
custom_format = getattr(self, '_repository_format', None)
2762
# We will use the custom format to create repositories over the
2763
# wire; expose its details like rich_root_data for code to query
2764
if isinstance(custom_format, remote.RemoteRepositoryFormat):
2765
result._custom_format = custom_format._custom_format
2767
result._custom_format = custom_format
2768
result.rich_root_data = custom_format.rich_root_data
2771
def get_branch_format(self):
2772
result = BzrDirMetaFormat1.get_branch_format(self)
2773
if not isinstance(result, remote.RemoteBranchFormat):
2774
new_result = remote.RemoteBranchFormat()
2775
new_result._custom_format = result
2777
self.set_branch_format(new_result)
2781
repository_format = property(__return_repository_format,
2782
BzrDirMetaFormat1._set_repository_format) #.im_func)
2785
BzrDirFormat.register_control_server_format(RemoteBzrDirFormat)
2788
class BzrDirFormatInfo(object):
2790
def __init__(self, native, deprecated, hidden, experimental):
2791
self.deprecated = deprecated
2792
self.native = native
2793
self.hidden = hidden
2794
self.experimental = experimental
2797
class BzrDirFormatRegistry(registry.Registry):
2798
"""Registry of user-selectable BzrDir subformats.
2800
Differs from BzrDirFormat._control_formats in that it provides sub-formats,
2801
e.g. BzrDirMeta1 with weave repository. Also, it's more user-oriented.
2805
"""Create a BzrDirFormatRegistry."""
2806
self._aliases = set()
2807
self._registration_order = list()
2808
super(BzrDirFormatRegistry, self).__init__()
2811
"""Return a set of the format names which are aliases."""
2812
return frozenset(self._aliases)
2814
def register_metadir(self, key,
2815
repository_format, help, native=True, deprecated=False,
2821
"""Register a metadir subformat.
2823
These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
2824
by the Repository format.
2826
:param repository_format: The fully-qualified repository format class
2828
:param branch_format: Fully-qualified branch format class name as
2830
:param tree_format: Fully-qualified tree format class name as
2833
# This should be expanded to support setting WorkingTree and Branch
2834
# formats, once BzrDirMetaFormat1 supports that.
2835
def _load(full_name):
2836
mod_name, factory_name = full_name.rsplit('.', 1)
2838
mod = __import__(mod_name, globals(), locals(),
2840
except ImportError, e:
2841
raise ImportError('failed to load %s: %s' % (full_name, e))
2843
factory = getattr(mod, factory_name)
2844
except AttributeError:
2845
raise AttributeError('no factory %s in module %r'
2850
bd = BzrDirMetaFormat1()
2851
if branch_format is not None:
2852
bd.set_branch_format(_load(branch_format))
2853
if tree_format is not None:
2854
bd.workingtree_format = _load(tree_format)
2855
if repository_format is not None:
2856
bd.repository_format = _load(repository_format)
2858
self.register(key, helper, help, native, deprecated, hidden,
2859
experimental, alias)
2861
def register(self, key, factory, help, native=True, deprecated=False,
2862
hidden=False, experimental=False, alias=False):
2863
"""Register a BzrDirFormat factory.
2865
The factory must be a callable that takes one parameter: the key.
2866
It must produce an instance of the BzrDirFormat when called.
2868
This function mainly exists to prevent the info object from being
2871
registry.Registry.register(self, key, factory, help,
2872
BzrDirFormatInfo(native, deprecated, hidden, experimental))
2874
self._aliases.add(key)
2875
self._registration_order.append(key)
2877
def register_lazy(self, key, module_name, member_name, help, native=True,
2878
deprecated=False, hidden=False, experimental=False, alias=False):
2879
registry.Registry.register_lazy(self, key, module_name, member_name,
2880
help, BzrDirFormatInfo(native, deprecated, hidden, experimental))
2882
self._aliases.add(key)
2883
self._registration_order.append(key)
2885
def set_default(self, key):
2886
"""Set the 'default' key to be a clone of the supplied key.
2888
This method must be called once and only once.
2890
registry.Registry.register(self, 'default', self.get(key),
2891
self.get_help(key), info=self.get_info(key))
2892
self._aliases.add('default')
2894
def set_default_repository(self, key):
2895
"""Set the FormatRegistry default and Repository default.
2897
This is a transitional method while Repository.set_default_format
2900
if 'default' in self:
2901
self.remove('default')
2902
self.set_default(key)
2903
format = self.get('default')()
2905
def make_bzrdir(self, key):
2906
return self.get(key)()
2908
def help_topic(self, topic):
2910
default_realkey = None
2911
default_help = self.get_help('default')
2913
for key in self._registration_order:
2914
if key == 'default':
2916
help = self.get_help(key)
2917
if help == default_help:
2918
default_realkey = key
2920
help_pairs.append((key, help))
2922
def wrapped(key, help, info):
2924
help = '(native) ' + help
2925
return ':%s:\n%s\n\n' % (key,
2926
textwrap.fill(help, initial_indent=' ',
2927
subsequent_indent=' '))
2928
if default_realkey is not None:
2929
output += wrapped(default_realkey, '(default) %s' % default_help,
2930
self.get_info('default'))
2931
deprecated_pairs = []
2932
experimental_pairs = []
2933
for key, help in help_pairs:
2934
info = self.get_info(key)
2937
elif info.deprecated:
2938
deprecated_pairs.append((key, help))
2939
elif info.experimental:
2940
experimental_pairs.append((key, help))
2942
output += wrapped(key, help, info)
2943
output += "\nSee ``bzr help formats`` for more about storage formats."
2945
if len(experimental_pairs) > 0:
2946
other_output += "Experimental formats are shown below.\n\n"
2947
for key, help in experimental_pairs:
2948
info = self.get_info(key)
2949
other_output += wrapped(key, help, info)
2952
"No experimental formats are available.\n\n"
2953
if len(deprecated_pairs) > 0:
2954
other_output += "\nDeprecated formats are shown below.\n\n"
2955
for key, help in deprecated_pairs:
2956
info = self.get_info(key)
2957
other_output += wrapped(key, help, info)
2960
"\nNo deprecated formats are available.\n\n"
2962
"\nSee ``bzr help formats`` for more about storage formats."
2964
if topic == 'other-formats':
2970
class RepositoryAcquisitionPolicy(object):
2971
"""Abstract base class for repository acquisition policies.
2973
A repository acquisition policy decides how a BzrDir acquires a repository
2974
for a branch that is being created. The most basic policy decision is
2975
whether to create a new repository or use an existing one.
2977
def __init__(self, stack_on, stack_on_pwd, require_stacking):
2980
:param stack_on: A location to stack on
2981
:param stack_on_pwd: If stack_on is relative, the location it is
2983
:param require_stacking: If True, it is a failure to not stack.
2985
self._stack_on = stack_on
2986
self._stack_on_pwd = stack_on_pwd
2987
self._require_stacking = require_stacking
2989
def configure_branch(self, branch):
2990
"""Apply any configuration data from this policy to the branch.
2992
Default implementation sets repository stacking.
2994
if self._stack_on is None:
2996
if self._stack_on_pwd is None:
2997
stack_on = self._stack_on
3000
stack_on = urlutils.rebase_url(self._stack_on,
3002
branch.bzrdir.root_transport.base)
3003
except errors.InvalidRebaseURLs:
3004
stack_on = self._get_full_stack_on()
3006
branch.set_stacked_on_url(stack_on)
3007
except errors.UnstackableBranchFormat:
3008
if self._require_stacking:
3011
def _get_full_stack_on(self):
3012
"""Get a fully-qualified URL for the stack_on location."""
3013
if self._stack_on is None:
3015
if self._stack_on_pwd is None:
3016
return self._stack_on
3018
return urlutils.join(self._stack_on_pwd, self._stack_on)
3020
def _add_fallback(self, repository, possible_transports=None):
3021
"""Add a fallback to the supplied repository, if stacking is set."""
3022
stack_on = self._get_full_stack_on()
3023
if stack_on is None:
3025
stacked_dir = BzrDir.open(stack_on,
3026
possible_transports=possible_transports)
3028
stacked_repo = stacked_dir.open_branch().repository
3029
except errors.NotBranchError:
3030
stacked_repo = stacked_dir.open_repository()
3032
repository.add_fallback_repository(stacked_repo)
3033
except errors.UnstackableRepositoryFormat:
3034
if self._require_stacking:
3037
self._require_stacking = True
3039
def acquire_repository(self, make_working_trees=None, shared=False):
3040
"""Acquire a repository for this bzrdir.
3042
Implementations may create a new repository or use a pre-exising
3044
:param make_working_trees: If creating a repository, set
3045
make_working_trees to this value (if non-None)
3046
:param shared: If creating a repository, make it shared if True
3047
:return: A repository
3049
raise NotImplemented(RepositoryAcquisitionPolicy.acquire_repository)
3052
class CreateRepository(RepositoryAcquisitionPolicy):
3053
"""A policy of creating a new repository"""
3055
def __init__(self, bzrdir, stack_on=None, stack_on_pwd=None,
3056
require_stacking=False):
3059
:param bzrdir: The bzrdir to create the repository on.
3060
:param stack_on: A location to stack on
3061
:param stack_on_pwd: If stack_on is relative, the location it is
3064
RepositoryAcquisitionPolicy.__init__(self, stack_on, stack_on_pwd,
3066
self._bzrdir = bzrdir
3068
def acquire_repository(self, make_working_trees=None, shared=False):
3069
"""Implementation of RepositoryAcquisitionPolicy.acquire_repository
3071
Creates the desired repository in the bzrdir we already have.
3073
repository = self._bzrdir.create_repository(shared=shared)
3074
self._add_fallback(repository,
3075
possible_transports=[self._bzrdir.transport])
3076
if make_working_trees is not None:
3077
repository.set_make_working_trees(make_working_trees)
3081
class UseExistingRepository(RepositoryAcquisitionPolicy):
3082
"""A policy of reusing an existing repository"""
3084
def __init__(self, repository, stack_on=None, stack_on_pwd=None,
3085
require_stacking=False):
3088
:param repository: The repository to use.
3089
:param stack_on: A location to stack on
3090
:param stack_on_pwd: If stack_on is relative, the location it is
3093
RepositoryAcquisitionPolicy.__init__(self, stack_on, stack_on_pwd,
3095
self._repository = repository
3097
def acquire_repository(self, make_working_trees=None, shared=False):
3098
"""Implementation of RepositoryAcquisitionPolicy.acquire_repository
3100
Returns an existing repository to use
3102
self._add_fallback(self._repository,
3103
possible_transports=[self._repository.bzrdir.transport])
3104
return self._repository
3107
# Please register new formats after old formats so that formats
3108
# appear in chronological order and format descriptions can build
3110
format_registry = BzrDirFormatRegistry()
3111
# The pre-0.8 formats have their repository format network name registered in
3112
# repository.py. MetaDir formats have their repository format network name
3113
# inferred from their disk format string.
3114
format_registry.register('weave', BzrDirFormat6,
3115
'Pre-0.8 format. Slower than knit and does not'
3116
' support checkouts or shared repositories.',
3118
format_registry.register_metadir('metaweave',
3119
'bzrlib.repofmt.weaverepo.RepositoryFormat7',
3120
'Transitional format in 0.8. Slower than knit.',
3121
branch_format='bzrlib.branch.BzrBranchFormat5',
3122
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3124
format_registry.register_metadir('knit',
3125
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3126
'Format using knits. Recommended for interoperation with bzr <= 0.14.',
3127
branch_format='bzrlib.branch.BzrBranchFormat5',
3128
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3130
format_registry.register_metadir('dirstate',
3131
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3132
help='New in 0.15: Fast local operations. Compatible with bzr 0.8 and '
3133
'above when accessed over the network.',
3134
branch_format='bzrlib.branch.BzrBranchFormat5',
3135
# this uses bzrlib.workingtree.WorkingTreeFormat4 because importing
3136
# directly from workingtree_4 triggers a circular import.
3137
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3139
format_registry.register_metadir('dirstate-tags',
3140
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3141
help='New in 0.15: Fast local operations and improved scaling for '
3142
'network operations. Additionally adds support for tags.'
3143
' Incompatible with bzr < 0.15.',
3144
branch_format='bzrlib.branch.BzrBranchFormat6',
3145
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3147
format_registry.register_metadir('rich-root',
3148
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit4',
3149
help='New in 1.0. Better handling of tree roots. Incompatible with'
3151
branch_format='bzrlib.branch.BzrBranchFormat6',
3152
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3154
format_registry.register_metadir('dirstate-with-subtree',
3155
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
3156
help='New in 0.15: Fast local operations and improved scaling for '
3157
'network operations. Additionally adds support for versioning nested '
3158
'bzr branches. Incompatible with bzr < 0.15.',
3159
branch_format='bzrlib.branch.BzrBranchFormat6',
3160
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3164
format_registry.register_metadir('pack-0.92',
3165
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack1',
3166
help='New in 0.92: Pack-based format with data compatible with '
3167
'dirstate-tags format repositories. Interoperates with '
3168
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3169
'Previously called knitpack-experimental. '
3170
'For more information, see '
3171
'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
3172
branch_format='bzrlib.branch.BzrBranchFormat6',
3173
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3175
format_registry.register_metadir('pack-0.92-subtree',
3176
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack3',
3177
help='New in 0.92: Pack-based format with data compatible with '
3178
'dirstate-with-subtree format repositories. Interoperates with '
3179
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3180
'Previously called knitpack-experimental. '
3181
'For more information, see '
3182
'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
3183
branch_format='bzrlib.branch.BzrBranchFormat6',
3184
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3188
format_registry.register_metadir('rich-root-pack',
3189
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack4',
3190
help='New in 1.0: A variant of pack-0.92 that supports rich-root data '
3191
'(needed for bzr-svn).',
3192
branch_format='bzrlib.branch.BzrBranchFormat6',
3193
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3195
format_registry.register_metadir('1.6',
3196
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5',
3197
help='A format that allows a branch to indicate that there is another '
3198
'(stacked) repository that should be used to access data that is '
3199
'not present locally.',
3200
branch_format='bzrlib.branch.BzrBranchFormat7',
3201
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3203
format_registry.register_metadir('1.6.1-rich-root',
3204
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5RichRoot',
3205
help='A variant of 1.6 that supports rich-root data '
3206
'(needed for bzr-svn).',
3207
branch_format='bzrlib.branch.BzrBranchFormat7',
3208
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3210
format_registry.register_metadir('1.9',
3211
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3212
help='A repository format using B+tree indexes. These indexes '
3213
'are smaller in size, have smarter caching and provide faster '
3214
'performance for most operations.',
3215
branch_format='bzrlib.branch.BzrBranchFormat7',
3216
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3218
format_registry.register_metadir('1.9-rich-root',
3219
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3220
help='A variant of 1.9 that supports rich-root data '
3221
'(needed for bzr-svn).',
3222
branch_format='bzrlib.branch.BzrBranchFormat7',
3223
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3225
format_registry.register_metadir('development-wt5',
3226
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3227
help='A working-tree format that supports views and content filtering.',
3228
branch_format='bzrlib.branch.BzrBranchFormat7',
3229
tree_format='bzrlib.workingtree.WorkingTreeFormat5',
3232
format_registry.register_metadir('development-wt5-rich-root',
3233
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3234
help='A variant of development-wt5 that supports rich-root data '
3235
'(needed for bzr-svn).',
3236
branch_format='bzrlib.branch.BzrBranchFormat7',
3237
tree_format='bzrlib.workingtree.WorkingTreeFormat5',
3240
# The following two formats should always just be aliases.
3241
format_registry.register_metadir('development',
3242
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2',
3243
help='Current development format. Can convert data to and from pack-0.92 '
3244
'(and anything compatible with pack-0.92) format repositories. '
3245
'Repositories and branches in this format can only be read by bzr.dev. '
3247
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3249
branch_format='bzrlib.branch.BzrBranchFormat7',
3250
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3254
format_registry.register_metadir('development-subtree',
3255
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
3256
help='Current development format, subtree variant. Can convert data to and '
3257
'from pack-0.92-subtree (and anything compatible with '
3258
'pack-0.92-subtree) format repositories. Repositories and branches in '
3259
'this format can only be read by bzr.dev. Please read '
3260
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3262
branch_format='bzrlib.branch.BzrBranchFormat7',
3263
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3267
# And the development formats above will have aliased one of the following:
3268
format_registry.register_metadir('development2',
3269
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2',
3270
help='1.6.1 with B+Tree based index. '
3272
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3274
branch_format='bzrlib.branch.BzrBranchFormat7',
3275
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3279
format_registry.register_metadir('development2-subtree',
3280
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
3281
help='1.6.1-subtree with B+Tree based index. '
3283
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3285
branch_format='bzrlib.branch.BzrBranchFormat7',
3286
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3290
# The current format that is made on 'bzr init'.
3291
format_registry.set_default('pack-0.92')
added
removed
bzrlib/bzrdir.py
