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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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
49
revision as _mod_revision,
59
from bzrlib.osutils import (
62
from bzrlib.push import (
65
from bzrlib.repofmt import pack_repo
66
from bzrlib.smart.client import _SmartClient
67
from bzrlib.store.versioned import WeaveStore
68
from bzrlib.transactions import WriteTransaction
69
from bzrlib.transport import (
70
do_catching_redirections,
74
from bzrlib.weave import Weave
77
from bzrlib.trace import (
91
"""A .bzr control diretory.
93
BzrDir instances let you create or open any of the things that can be
94
found within .bzr - checkouts, branches and repositories.
97
the transport which this bzr dir is rooted at (i.e. file:///.../.bzr/)
99
a transport connected to the directory this bzr was opened from
100
(i.e. the parent directory holding the .bzr directory).
102
Everything in the bzrdir should have the same file permissions.
104
:cvar hooks: An instance of BzrDirHooks.
107
def break_lock(self):
108
"""Invoke break_lock on the first object in the bzrdir.
110
If there is a tree, the tree is opened and break_lock() called.
111
Otherwise, branch is tried, and finally repository.
113
# XXX: This seems more like a UI function than something that really
114
# belongs in this class.
116
thing_to_unlock = self.open_workingtree()
117
except (errors.NotLocalUrl, errors.NoWorkingTree):
119
thing_to_unlock = self.open_branch()
120
except errors.NotBranchError:
122
thing_to_unlock = self.open_repository()
123
except errors.NoRepositoryPresent:
125
thing_to_unlock.break_lock()
127
def can_convert_format(self):
128
"""Return true if this bzrdir is one whose format we can convert from."""
131
def check_conversion_target(self, target_format):
132
target_repo_format = target_format.repository_format
133
source_repo_format = self._format.repository_format
134
source_repo_format.check_conversion_target(target_repo_format)
137
def _check_supported(format, allow_unsupported,
138
recommend_upgrade=True,
140
"""Give an error or warning on old formats.
142
:param format: may be any kind of format - workingtree, branch,
145
:param allow_unsupported: If true, allow opening
146
formats that are strongly deprecated, and which may
147
have limited functionality.
149
:param recommend_upgrade: If true (default), warn
150
the user through the ui object that they may wish
151
to upgrade the object.
153
# TODO: perhaps move this into a base Format class; it's not BzrDir
154
# specific. mbp 20070323
155
if not allow_unsupported and not format.is_supported():
156
# see open_downlevel to open legacy branches.
157
raise errors.UnsupportedFormatError(format=format)
158
if recommend_upgrade \
159
and getattr(format, 'upgrade_recommended', False):
160
ui.ui_factory.recommend_upgrade(
161
format.get_format_description(),
164
def clone(self, url, revision_id=None, force_new_repo=False,
165
preserve_stacking=False):
166
"""Clone this bzrdir and its contents to url verbatim.
168
:param url: The url create the clone at. If url's last component does
169
not exist, it will be created.
170
:param revision_id: The tip revision-id to use for any branch or
171
working tree. If not None, then the clone operation may tune
172
itself to download less data.
173
:param force_new_repo: Do not use a shared repository for the target
174
even if one is available.
175
:param preserve_stacking: When cloning a stacked branch, stack the
176
new branch on top of the other branch's stacked-on branch.
178
return self.clone_on_transport(get_transport(url),
179
revision_id=revision_id,
180
force_new_repo=force_new_repo,
181
preserve_stacking=preserve_stacking)
183
def clone_on_transport(self, transport, revision_id=None,
184
force_new_repo=False, preserve_stacking=False, stacked_on=None,
185
create_prefix=False, use_existing_dir=True):
186
"""Clone this bzrdir and its contents to transport verbatim.
188
:param transport: The transport for the location to produce the clone
189
at. If the target directory does not exist, it will be created.
190
:param revision_id: The tip revision-id to use for any branch or
191
working tree. If not None, then the clone operation may tune
192
itself to download less data.
193
:param force_new_repo: Do not use a shared repository for the target,
194
even if one is available.
195
:param preserve_stacking: When cloning a stacked branch, stack the
196
new branch on top of the other branch's stacked-on branch.
197
:param create_prefix: Create any missing directories leading up to
199
:param use_existing_dir: Use an existing directory if one exists.
201
# Overview: put together a broad description of what we want to end up
202
# with; then make as few api calls as possible to do it.
204
# We may want to create a repo/branch/tree, if we do so what format
205
# would we want for each:
206
require_stacking = (stacked_on is not None)
207
format = self.cloning_metadir(require_stacking)
209
# Figure out what objects we want:
211
local_repo = self.find_repository()
212
except errors.NoRepositoryPresent:
215
local_branch = self.open_branch()
216
except errors.NotBranchError:
219
# enable fallbacks when branch is not a branch reference
220
if local_branch.repository.has_same_location(local_repo):
221
local_repo = local_branch.repository
222
if preserve_stacking:
224
stacked_on = local_branch.get_stacked_on_url()
225
except (errors.UnstackableBranchFormat,
226
errors.UnstackableRepositoryFormat,
229
# Bug: We create a metadir without knowing if it can support stacking,
230
# we should look up the policy needs first, or just use it as a hint,
233
make_working_trees = local_repo.make_working_trees()
234
want_shared = local_repo.is_shared()
235
repo_format_name = format.repository_format.network_name()
237
make_working_trees = False
239
repo_format_name = None
241
result_repo, result, require_stacking, repository_policy = \
242
format.initialize_on_transport_ex(transport,
243
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
244
force_new_repo=force_new_repo, stacked_on=stacked_on,
245
stack_on_pwd=self.root_transport.base,
246
repo_format_name=repo_format_name,
247
make_working_trees=make_working_trees, shared_repo=want_shared)
250
# If the result repository is in the same place as the
251
# resulting bzr dir, it will have no content, further if the
252
# result is not stacked then we know all content should be
253
# copied, and finally if we are copying up to a specific
254
# revision_id then we can use the pending-ancestry-result which
255
# does not require traversing all of history to describe it.
256
if (result_repo.bzrdir.root_transport.base ==
257
result.root_transport.base and not require_stacking and
258
revision_id is not None):
259
fetch_spec = graph.PendingAncestryResult(
260
[revision_id], local_repo)
261
result_repo.fetch(local_repo, fetch_spec=fetch_spec)
263
result_repo.fetch(local_repo, revision_id=revision_id)
267
if result_repo is not None:
268
raise AssertionError('result_repo not None(%r)' % result_repo)
269
# 1 if there is a branch present
270
# make sure its content is available in the target repository
272
if local_branch is not None:
273
result_branch = local_branch.clone(result, revision_id=revision_id,
274
repository_policy=repository_policy)
276
# Cheaper to check if the target is not local, than to try making
278
result.root_transport.local_abspath('.')
279
if result_repo is None or result_repo.make_working_trees():
280
self.open_workingtree().clone(result)
281
except (errors.NoWorkingTree, errors.NotLocalUrl):
285
# TODO: This should be given a Transport, and should chdir up; otherwise
286
# this will open a new connection.
287
def _make_tail(self, url):
288
t = get_transport(url)
292
def create(cls, base, format=None, possible_transports=None):
293
"""Create a new BzrDir at the url 'base'.
295
:param format: If supplied, the format of branch to create. If not
296
supplied, the default is used.
297
:param possible_transports: If supplied, a list of transports that
298
can be reused to share a remote connection.
300
if cls is not BzrDir:
301
raise AssertionError("BzrDir.create always creates the default"
302
" format, not one of %r" % cls)
303
t = get_transport(base, possible_transports)
306
format = BzrDirFormat.get_default_format()
307
return format.initialize_on_transport(t)
310
def find_bzrdirs(transport, evaluate=None, list_current=None):
311
"""Find bzrdirs recursively from current location.
313
This is intended primarily as a building block for more sophisticated
314
functionality, like finding trees under a directory, or finding
315
branches that use a given repository.
316
:param evaluate: An optional callable that yields recurse, value,
317
where recurse controls whether this bzrdir is recursed into
318
and value is the value to yield. By default, all bzrdirs
319
are recursed into, and the return value is the bzrdir.
320
:param list_current: if supplied, use this function to list the current
321
directory, instead of Transport.list_dir
322
:return: a generator of found bzrdirs, or whatever evaluate returns.
324
if list_current is None:
325
def list_current(transport):
326
return transport.list_dir('')
328
def evaluate(bzrdir):
331
pending = [transport]
332
while len(pending) > 0:
333
current_transport = pending.pop()
336
bzrdir = BzrDir.open_from_transport(current_transport)
337
except errors.NotBranchError:
340
recurse, value = evaluate(bzrdir)
343
subdirs = list_current(current_transport)
344
except errors.NoSuchFile:
347
for subdir in sorted(subdirs, reverse=True):
348
pending.append(current_transport.clone(subdir))
351
def find_branches(transport):
352
"""Find all branches under a transport.
354
This will find all branches below the transport, including branches
355
inside other branches. Where possible, it will use
356
Repository.find_branches.
358
To list all the branches that use a particular Repository, see
359
Repository.find_branches
361
def evaluate(bzrdir):
363
repository = bzrdir.open_repository()
364
except errors.NoRepositoryPresent:
367
return False, (None, repository)
369
branch = bzrdir.open_branch()
370
except errors.NotBranchError:
371
return True, (None, None)
373
return True, (branch, None)
375
for branch, repo in BzrDir.find_bzrdirs(transport, evaluate=evaluate):
377
branches.extend(repo.find_branches())
378
if branch is not None:
379
branches.append(branch)
382
def destroy_repository(self):
383
"""Destroy the repository in this BzrDir"""
384
raise NotImplementedError(self.destroy_repository)
386
def create_branch(self):
387
"""Create a branch in this BzrDir.
389
The bzrdir's format will control what branch format is created.
390
For more control see BranchFormatXX.create(a_bzrdir).
392
raise NotImplementedError(self.create_branch)
394
def destroy_branch(self):
395
"""Destroy the branch in this BzrDir"""
396
raise NotImplementedError(self.destroy_branch)
399
def create_branch_and_repo(base, force_new_repo=False, format=None):
400
"""Create a new BzrDir, Branch and Repository at the url 'base'.
402
This will use the current default BzrDirFormat unless one is
403
specified, and use whatever
404
repository format that that uses via bzrdir.create_branch and
405
create_repository. If a shared repository is available that is used
408
The created Branch object is returned.
410
:param base: The URL to create the branch at.
411
:param force_new_repo: If True a new repository is always created.
412
:param format: If supplied, the format of branch to create. If not
413
supplied, the default is used.
415
bzrdir = BzrDir.create(base, format)
416
bzrdir._find_or_create_repository(force_new_repo)
417
return bzrdir.create_branch()
419
def determine_repository_policy(self, force_new_repo=False, stack_on=None,
420
stack_on_pwd=None, require_stacking=False):
421
"""Return an object representing a policy to use.
423
This controls whether a new repository is created, and the format of
424
that repository, or some existing shared repository used instead.
426
If stack_on is supplied, will not seek a containing shared repo.
428
:param force_new_repo: If True, require a new repository to be created.
429
:param stack_on: If supplied, the location to stack on. If not
430
supplied, a default_stack_on location may be used.
431
:param stack_on_pwd: If stack_on is relative, the location it is
434
def repository_policy(found_bzrdir):
437
config = found_bzrdir.get_config()
439
stack_on = config.get_default_stack_on()
440
if stack_on is not None:
441
stack_on_pwd = found_bzrdir.root_transport.base
443
# does it have a repository ?
445
repository = found_bzrdir.open_repository()
446
except errors.NoRepositoryPresent:
449
if ((found_bzrdir.root_transport.base !=
450
self.root_transport.base) and not repository.is_shared()):
451
# Don't look higher, can't use a higher shared repo.
459
return UseExistingRepository(repository, stack_on,
460
stack_on_pwd, require_stacking=require_stacking), True
462
return CreateRepository(self, stack_on, stack_on_pwd,
463
require_stacking=require_stacking), True
465
if not force_new_repo:
467
policy = self._find_containing(repository_policy)
468
if policy is not None:
472
return UseExistingRepository(self.open_repository(),
473
stack_on, stack_on_pwd,
474
require_stacking=require_stacking)
475
except errors.NoRepositoryPresent:
477
return CreateRepository(self, stack_on, stack_on_pwd,
478
require_stacking=require_stacking)
480
def _find_or_create_repository(self, force_new_repo):
481
"""Create a new repository if needed, returning the repository."""
482
policy = self.determine_repository_policy(force_new_repo)
483
return policy.acquire_repository()[0]
486
def create_branch_convenience(base, force_new_repo=False,
487
force_new_tree=None, format=None,
488
possible_transports=None):
489
"""Create a new BzrDir, Branch and Repository at the url 'base'.
491
This is a convenience function - it will use an existing repository
492
if possible, can be told explicitly whether to create a working tree or
495
This will use the current default BzrDirFormat unless one is
496
specified, and use whatever
497
repository format that that uses via bzrdir.create_branch and
498
create_repository. If a shared repository is available that is used
499
preferentially. Whatever repository is used, its tree creation policy
502
The created Branch object is returned.
503
If a working tree cannot be made due to base not being a file:// url,
504
no error is raised unless force_new_tree is True, in which case no
505
data is created on disk and NotLocalUrl is raised.
507
:param base: The URL to create the branch at.
508
:param force_new_repo: If True a new repository is always created.
509
:param force_new_tree: If True or False force creation of a tree or
510
prevent such creation respectively.
511
:param format: Override for the bzrdir format to create.
512
:param possible_transports: An optional reusable transports list.
515
# check for non local urls
516
t = get_transport(base, possible_transports)
517
if not isinstance(t, local.LocalTransport):
518
raise errors.NotLocalUrl(base)
519
bzrdir = BzrDir.create(base, format, possible_transports)
520
repo = bzrdir._find_or_create_repository(force_new_repo)
521
result = bzrdir.create_branch()
522
if force_new_tree or (repo.make_working_trees() and
523
force_new_tree is None):
525
bzrdir.create_workingtree()
526
except errors.NotLocalUrl:
531
def create_standalone_workingtree(base, format=None):
532
"""Create a new BzrDir, WorkingTree, Branch and Repository at 'base'.
534
'base' must be a local path or a file:// url.
536
This will use the current default BzrDirFormat unless one is
537
specified, and use whatever
538
repository format that that uses for bzrdirformat.create_workingtree,
539
create_branch and create_repository.
541
:param format: Override for the bzrdir format to create.
542
:return: The WorkingTree object.
544
t = get_transport(base)
545
if not isinstance(t, local.LocalTransport):
546
raise errors.NotLocalUrl(base)
547
bzrdir = BzrDir.create_branch_and_repo(base,
549
format=format).bzrdir
550
return bzrdir.create_workingtree()
552
def create_workingtree(self, revision_id=None, from_branch=None,
553
accelerator_tree=None, hardlink=False):
554
"""Create a working tree at this BzrDir.
556
:param revision_id: create it as of this revision id.
557
:param from_branch: override bzrdir branch (for lightweight checkouts)
558
:param accelerator_tree: A tree which can be used for retrieving file
559
contents more quickly than the revision tree, i.e. a workingtree.
560
The revision tree will be used for cases where accelerator_tree's
561
content is different.
563
raise NotImplementedError(self.create_workingtree)
565
def backup_bzrdir(self):
566
"""Backup this bzr control directory.
568
:return: Tuple with old path name and new path name
570
pb = ui.ui_factory.nested_progress_bar()
572
# FIXME: bug 300001 -- the backup fails if the backup directory
573
# already exists, but it should instead either remove it or make
574
# a new backup directory.
576
# FIXME: bug 262450 -- the backup directory should have the same
577
# permissions as the .bzr directory (probably a bug in copy_tree)
578
old_path = self.root_transport.abspath('.bzr')
579
new_path = self.root_transport.abspath('backup.bzr')
580
pb.note('making backup of %s' % (old_path,))
581
pb.note(' to %s' % (new_path,))
582
self.root_transport.copy_tree('.bzr', 'backup.bzr')
583
return (old_path, new_path)
587
def retire_bzrdir(self, limit=10000):
588
"""Permanently disable the bzrdir.
590
This is done by renaming it to give the user some ability to recover
591
if there was a problem.
593
This will have horrible consequences if anyone has anything locked or
595
:param limit: number of times to retry
600
to_path = '.bzr.retired.%d' % i
601
self.root_transport.rename('.bzr', to_path)
602
note("renamed %s to %s"
603
% (self.root_transport.abspath('.bzr'), to_path))
605
except (errors.TransportError, IOError, errors.PathError):
612
def destroy_workingtree(self):
613
"""Destroy the working tree at this BzrDir.
615
Formats that do not support this may raise UnsupportedOperation.
617
raise NotImplementedError(self.destroy_workingtree)
619
def destroy_workingtree_metadata(self):
620
"""Destroy the control files for the working tree at this BzrDir.
622
The contents of working tree files are not affected.
623
Formats that do not support this may raise UnsupportedOperation.
625
raise NotImplementedError(self.destroy_workingtree_metadata)
627
def _find_containing(self, evaluate):
628
"""Find something in a containing control directory.
630
This method will scan containing control dirs, until it finds what
631
it is looking for, decides that it will never find it, or runs out
632
of containing control directories to check.
634
It is used to implement find_repository and
635
determine_repository_policy.
637
:param evaluate: A function returning (value, stop). If stop is True,
638
the value will be returned.
642
result, stop = evaluate(found_bzrdir)
645
next_transport = found_bzrdir.root_transport.clone('..')
646
if (found_bzrdir.root_transport.base == next_transport.base):
647
# top of the file system
649
# find the next containing bzrdir
651
found_bzrdir = BzrDir.open_containing_from_transport(
653
except errors.NotBranchError:
656
def find_repository(self):
657
"""Find the repository that should be used.
659
This does not require a branch as we use it to find the repo for
660
new branches as well as to hook existing branches up to their
663
def usable_repository(found_bzrdir):
664
# does it have a repository ?
666
repository = found_bzrdir.open_repository()
667
except errors.NoRepositoryPresent:
669
if found_bzrdir.root_transport.base == self.root_transport.base:
670
return repository, True
671
elif repository.is_shared():
672
return repository, True
676
found_repo = self._find_containing(usable_repository)
677
if found_repo is None:
678
raise errors.NoRepositoryPresent(self)
681
def get_branch_reference(self):
682
"""Return the referenced URL for the branch in this bzrdir.
684
:raises NotBranchError: If there is no Branch.
685
:return: The URL the branch in this bzrdir references if it is a
686
reference branch, or None for regular branches.
690
def get_branch_transport(self, branch_format):
691
"""Get the transport for use by branch format in this BzrDir.
693
Note that bzr dirs that do not support format strings will raise
694
IncompatibleFormat if the branch format they are given has
695
a format string, and vice versa.
697
If branch_format is None, the transport is returned with no
698
checking. If it is not None, then the returned transport is
699
guaranteed to point to an existing directory ready for use.
701
raise NotImplementedError(self.get_branch_transport)
703
def _find_creation_modes(self):
704
"""Determine the appropriate modes for files and directories.
706
They're always set to be consistent with the base directory,
707
assuming that this transport allows setting modes.
709
# TODO: Do we need or want an option (maybe a config setting) to turn
710
# this off or override it for particular locations? -- mbp 20080512
711
if self._mode_check_done:
713
self._mode_check_done = True
715
st = self.transport.stat('.')
716
except errors.TransportNotPossible:
717
self._dir_mode = None
718
self._file_mode = None
720
# Check the directory mode, but also make sure the created
721
# directories and files are read-write for this user. This is
722
# mostly a workaround for filesystems which lie about being able to
723
# write to a directory (cygwin & win32)
724
if (st.st_mode & 07777 == 00000):
725
# FTP allows stat but does not return dir/file modes
726
self._dir_mode = None
727
self._file_mode = None
729
self._dir_mode = (st.st_mode & 07777) | 00700
730
# Remove the sticky and execute bits for files
731
self._file_mode = self._dir_mode & ~07111
733
def _get_file_mode(self):
734
"""Return Unix mode for newly created files, or None.
736
if not self._mode_check_done:
737
self._find_creation_modes()
738
return self._file_mode
740
def _get_dir_mode(self):
741
"""Return Unix mode for newly created directories, or None.
743
if not self._mode_check_done:
744
self._find_creation_modes()
745
return self._dir_mode
747
def get_repository_transport(self, repository_format):
748
"""Get the transport for use by repository format in this BzrDir.
750
Note that bzr dirs that do not support format strings will raise
751
IncompatibleFormat if the repository format they are given has
752
a format string, and vice versa.
754
If repository_format is None, the transport is returned with no
755
checking. If it is not None, then the returned transport is
756
guaranteed to point to an existing directory ready for use.
758
raise NotImplementedError(self.get_repository_transport)
760
def get_workingtree_transport(self, tree_format):
761
"""Get the transport for use by workingtree format in this BzrDir.
763
Note that bzr dirs that do not support format strings will raise
764
IncompatibleFormat if the workingtree format they are given has a
765
format string, and vice versa.
767
If workingtree_format is None, the transport is returned with no
768
checking. If it is not None, then the returned transport is
769
guaranteed to point to an existing directory ready for use.
771
raise NotImplementedError(self.get_workingtree_transport)
773
def get_config(self):
774
"""Get configuration for this BzrDir."""
775
return config.BzrDirConfig(self)
777
def _get_config(self):
778
"""By default, no configuration is available."""
781
def __init__(self, _transport, _format):
782
"""Initialize a Bzr control dir object.
784
Only really common logic should reside here, concrete classes should be
785
made with varying behaviours.
787
:param _format: the format that is creating this BzrDir instance.
788
:param _transport: the transport this dir is based at.
790
self._format = _format
791
self.transport = _transport.clone('.bzr')
792
self.root_transport = _transport
793
self._mode_check_done = False
795
def is_control_filename(self, filename):
796
"""True if filename is the name of a path which is reserved for bzrdir's.
798
:param filename: A filename within the root transport of this bzrdir.
800
This is true IF and ONLY IF the filename is part of the namespace reserved
801
for bzr control dirs. Currently this is the '.bzr' directory in the root
802
of the root_transport. it is expected that plugins will need to extend
803
this in the future - for instance to make bzr talk with svn working
806
# this might be better on the BzrDirFormat class because it refers to
807
# all the possible bzrdir disk formats.
808
# This method is tested via the workingtree is_control_filename tests-
809
# it was extracted from WorkingTree.is_control_filename. If the method's
810
# contract is extended beyond the current trivial implementation, please
811
# add new tests for it to the appropriate place.
812
return filename == '.bzr' or filename.startswith('.bzr/')
814
def needs_format_conversion(self, format=None):
815
"""Return true if this bzrdir needs convert_format run on it.
817
For instance, if the repository format is out of date but the
818
branch and working tree are not, this should return True.
820
:param format: Optional parameter indicating a specific desired
821
format we plan to arrive at.
823
raise NotImplementedError(self.needs_format_conversion)
826
def open_unsupported(base):
827
"""Open a branch which is not supported."""
828
return BzrDir.open(base, _unsupported=True)
831
def open(base, _unsupported=False, possible_transports=None):
832
"""Open an existing bzrdir, rooted at 'base' (url).
834
:param _unsupported: a private parameter to the BzrDir class.
836
t = get_transport(base, possible_transports=possible_transports)
837
return BzrDir.open_from_transport(t, _unsupported=_unsupported)
840
def open_from_transport(transport, _unsupported=False,
841
_server_formats=True):
842
"""Open a bzrdir within a particular directory.
844
:param transport: Transport containing the bzrdir.
845
:param _unsupported: private.
847
for hook in BzrDir.hooks['pre_open']:
849
# Keep initial base since 'transport' may be modified while following
851
base = transport.base
852
def find_format(transport):
853
return transport, BzrDirFormat.find_format(
854
transport, _server_formats=_server_formats)
856
def redirected(transport, e, redirection_notice):
857
redirected_transport = transport._redirected_to(e.source, e.target)
858
if redirected_transport is None:
859
raise errors.NotBranchError(base)
860
note('%s is%s redirected to %s',
861
transport.base, e.permanently, redirected_transport.base)
862
return redirected_transport
865
transport, format = do_catching_redirections(find_format,
868
except errors.TooManyRedirections:
869
raise errors.NotBranchError(base)
871
BzrDir._check_supported(format, _unsupported)
872
return format.open(transport, _found=True)
874
def open_branch(self, unsupported=False, ignore_fallbacks=False):
875
"""Open the branch object at this BzrDir if one is present.
877
If unsupported is True, then no longer supported branch formats can
880
TODO: static convenience version of this?
882
raise NotImplementedError(self.open_branch)
885
def open_containing(url, possible_transports=None):
886
"""Open an existing branch which contains url.
888
:param url: url to search from.
889
See open_containing_from_transport for more detail.
891
transport = get_transport(url, possible_transports)
892
return BzrDir.open_containing_from_transport(transport)
895
def open_containing_from_transport(a_transport):
896
"""Open an existing branch which contains a_transport.base.
898
This probes for a branch at a_transport, and searches upwards from there.
900
Basically we keep looking up until we find the control directory or
901
run into the root. If there isn't one, raises NotBranchError.
902
If there is one and it is either an unrecognised format or an unsupported
903
format, UnknownFormatError or UnsupportedFormatError are raised.
904
If there is one, it is returned, along with the unused portion of url.
906
:return: The BzrDir that contains the path, and a Unicode path
907
for the rest of the URL.
909
# this gets the normalised url back. I.e. '.' -> the full path.
910
url = a_transport.base
913
result = BzrDir.open_from_transport(a_transport)
914
return result, urlutils.unescape(a_transport.relpath(url))
915
except errors.NotBranchError, e:
918
new_t = a_transport.clone('..')
919
except errors.InvalidURLJoin:
920
# reached the root, whatever that may be
921
raise errors.NotBranchError(path=url)
922
if new_t.base == a_transport.base:
923
# reached the root, whatever that may be
924
raise errors.NotBranchError(path=url)
927
def _get_tree_branch(self):
928
"""Return the branch and tree, if any, for this bzrdir.
930
Return None for tree if not present or inaccessible.
931
Raise NotBranchError if no branch is present.
932
:return: (tree, branch)
935
tree = self.open_workingtree()
936
except (errors.NoWorkingTree, errors.NotLocalUrl):
938
branch = self.open_branch()
944
def open_tree_or_branch(klass, location):
945
"""Return the branch and working tree at a location.
947
If there is no tree at the location, tree will be None.
948
If there is no branch at the location, an exception will be
950
:return: (tree, branch)
952
bzrdir = klass.open(location)
953
return bzrdir._get_tree_branch()
956
def open_containing_tree_or_branch(klass, location):
957
"""Return the branch and working tree contained by a location.
959
Returns (tree, branch, relpath).
960
If there is no tree at containing the location, tree will be None.
961
If there is no branch containing the location, an exception will be
963
relpath is the portion of the path that is contained by the branch.
965
bzrdir, relpath = klass.open_containing(location)
966
tree, branch = bzrdir._get_tree_branch()
967
return tree, branch, relpath
970
def open_containing_tree_branch_or_repository(klass, location):
971
"""Return the working tree, branch and repo contained by a location.
973
Returns (tree, branch, repository, relpath).
974
If there is no tree containing the location, tree will be None.
975
If there is no branch containing the location, branch will be None.
976
If there is no repository containing the location, repository will be
978
relpath is the portion of the path that is contained by the innermost
981
If no tree, branch or repository is found, a NotBranchError is raised.
983
bzrdir, relpath = klass.open_containing(location)
985
tree, branch = bzrdir._get_tree_branch()
986
except errors.NotBranchError:
988
repo = bzrdir.find_repository()
989
return None, None, repo, relpath
990
except (errors.NoRepositoryPresent):
991
raise errors.NotBranchError(location)
992
return tree, branch, branch.repository, relpath
994
def open_repository(self, _unsupported=False):
995
"""Open the repository object at this BzrDir if one is present.
997
This will not follow the Branch object pointer - it's strictly a direct
998
open facility. Most client code should use open_branch().repository to
1001
:param _unsupported: a private parameter, not part of the api.
1002
TODO: static convenience version of this?
1004
raise NotImplementedError(self.open_repository)
1006
def open_workingtree(self, _unsupported=False,
1007
recommend_upgrade=True, from_branch=None):
1008
"""Open the workingtree object at this BzrDir if one is present.
1010
:param recommend_upgrade: Optional keyword parameter, when True (the
1011
default), emit through the ui module a recommendation that the user
1012
upgrade the working tree when the workingtree being opened is old
1013
(but still fully supported).
1014
:param from_branch: override bzrdir branch (for lightweight checkouts)
1016
raise NotImplementedError(self.open_workingtree)
1018
def has_branch(self):
1019
"""Tell if this bzrdir contains a branch.
1021
Note: if you're going to open the branch, you should just go ahead
1022
and try, and not ask permission first. (This method just opens the
1023
branch and discards it, and that's somewhat expensive.)
1028
except errors.NotBranchError:
1031
def has_workingtree(self):
1032
"""Tell if this bzrdir contains a working tree.
1034
This will still raise an exception if the bzrdir has a workingtree that
1035
is remote & inaccessible.
1037
Note: if you're going to open the working tree, you should just go ahead
1038
and try, and not ask permission first. (This method just opens the
1039
workingtree and discards it, and that's somewhat expensive.)
1042
self.open_workingtree(recommend_upgrade=False)
1044
except errors.NoWorkingTree:
1047
def _cloning_metadir(self):
1048
"""Produce a metadir suitable for cloning with.
1050
:returns: (destination_bzrdir_format, source_repository)
1052
result_format = self._format.__class__()
1055
branch = self.open_branch(ignore_fallbacks=True)
1056
source_repository = branch.repository
1057
result_format._branch_format = branch._format
1058
except errors.NotBranchError:
1059
source_branch = None
1060
source_repository = self.open_repository()
1061
except errors.NoRepositoryPresent:
1062
source_repository = None
1064
# XXX TODO: This isinstance is here because we have not implemented
1065
# the fix recommended in bug # 103195 - to delegate this choice the
1066
# repository itself.
1067
repo_format = source_repository._format
1068
if isinstance(repo_format, remote.RemoteRepositoryFormat):
1069
source_repository._ensure_real()
1070
repo_format = source_repository._real_repository._format
1071
result_format.repository_format = repo_format
1073
# TODO: Couldn't we just probe for the format in these cases,
1074
# rather than opening the whole tree? It would be a little
1075
# faster. mbp 20070401
1076
tree = self.open_workingtree(recommend_upgrade=False)
1077
except (errors.NoWorkingTree, errors.NotLocalUrl):
1078
result_format.workingtree_format = None
1080
result_format.workingtree_format = tree._format.__class__()
1081
return result_format, source_repository
1083
def cloning_metadir(self, require_stacking=False):
1084
"""Produce a metadir suitable for cloning or sprouting with.
1086
These operations may produce workingtrees (yes, even though they're
1087
"cloning" something that doesn't have a tree), so a viable workingtree
1088
format must be selected.
1090
:require_stacking: If True, non-stackable formats will be upgraded
1091
to similar stackable formats.
1092
:returns: a BzrDirFormat with all component formats either set
1093
appropriately or set to None if that component should not be
1096
format, repository = self._cloning_metadir()
1097
if format._workingtree_format is None:
1099
if repository is None:
1100
# No repository either
1102
# We have a repository, so set a working tree? (Why? This seems to
1103
# contradict the stated return value in the docstring).
1104
tree_format = repository._format._matchingbzrdir.workingtree_format
1105
format.workingtree_format = tree_format.__class__()
1106
if require_stacking:
1107
format.require_stacking()
1110
def checkout_metadir(self):
1111
return self.cloning_metadir()
1113
def sprout(self, url, revision_id=None, force_new_repo=False,
1114
recurse='down', possible_transports=None,
1115
accelerator_tree=None, hardlink=False, stacked=False,
1116
source_branch=None, create_tree_if_local=True):
1117
"""Create a copy of this bzrdir prepared for use as a new line of
1120
If url's last component does not exist, it will be created.
1122
Attributes related to the identity of the source branch like
1123
branch nickname will be cleaned, a working tree is created
1124
whether one existed before or not; and a local branch is always
1127
if revision_id is not None, then the clone operation may tune
1128
itself to download less data.
1129
:param accelerator_tree: A tree which can be used for retrieving file
1130
contents more quickly than the revision tree, i.e. a workingtree.
1131
The revision tree will be used for cases where accelerator_tree's
1132
content is different.
1133
:param hardlink: If true, hard-link files from accelerator_tree,
1135
:param stacked: If true, create a stacked branch referring to the
1136
location of this control directory.
1137
:param create_tree_if_local: If true, a working-tree will be created
1138
when working locally.
1140
target_transport = get_transport(url, possible_transports)
1141
target_transport.ensure_base()
1142
cloning_format = self.cloning_metadir(stacked)
1143
# Create/update the result branch
1144
result = cloning_format.initialize_on_transport(target_transport)
1145
# if a stacked branch wasn't requested, we don't create one
1146
# even if the origin was stacked
1147
stacked_branch_url = None
1148
if source_branch is not None:
1150
stacked_branch_url = self.root_transport.base
1151
source_repository = source_branch.repository
1154
source_branch = self.open_branch()
1155
source_repository = source_branch.repository
1157
stacked_branch_url = self.root_transport.base
1158
except errors.NotBranchError:
1159
source_branch = None
1161
source_repository = self.open_repository()
1162
except errors.NoRepositoryPresent:
1163
source_repository = None
1164
repository_policy = result.determine_repository_policy(
1165
force_new_repo, stacked_branch_url, require_stacking=stacked)
1166
result_repo, is_new_repo = repository_policy.acquire_repository()
1167
if is_new_repo and revision_id is not None and not stacked:
1168
fetch_spec = graph.PendingAncestryResult(
1169
[revision_id], source_repository)
1172
if source_repository is not None:
1173
# Fetch while stacked to prevent unstacked fetch from
1175
if fetch_spec is None:
1176
result_repo.fetch(source_repository, revision_id=revision_id)
1178
result_repo.fetch(source_repository, fetch_spec=fetch_spec)
1180
if source_branch is None:
1181
# this is for sprouting a bzrdir without a branch; is that
1183
# Not especially, but it's part of the contract.
1184
result_branch = result.create_branch()
1186
result_branch = source_branch.sprout(result,
1187
revision_id=revision_id, repository_policy=repository_policy)
1188
mutter("created new branch %r" % (result_branch,))
1190
# Create/update the result working tree
1191
if (create_tree_if_local and
1192
isinstance(target_transport, local.LocalTransport) and
1193
(result_repo is None or result_repo.make_working_trees())):
1194
wt = result.create_workingtree(accelerator_tree=accelerator_tree,
1198
if wt.path2id('') is None:
1200
wt.set_root_id(self.open_workingtree.get_root_id())
1201
except errors.NoWorkingTree:
1207
if recurse == 'down':
1209
basis = wt.basis_tree()
1211
subtrees = basis.iter_references()
1212
elif result_branch is not None:
1213
basis = result_branch.basis_tree()
1215
subtrees = basis.iter_references()
1216
elif source_branch is not None:
1217
basis = source_branch.basis_tree()
1219
subtrees = basis.iter_references()
1224
for path, file_id in subtrees:
1225
target = urlutils.join(url, urlutils.escape(path))
1226
sublocation = source_branch.reference_parent(file_id, path)
1227
sublocation.bzrdir.sprout(target,
1228
basis.get_reference_revision(file_id, path),
1229
force_new_repo=force_new_repo, recurse=recurse,
1232
if basis is not None:
1236
def push_branch(self, source, revision_id=None, overwrite=False,
1237
remember=False, create_prefix=False):
1238
"""Push the source branch into this BzrDir."""
1240
# If we can open a branch, use its direct repository, otherwise see
1241
# if there is a repository without a branch.
1243
br_to = self.open_branch()
1244
except errors.NotBranchError:
1245
# Didn't find a branch, can we find a repository?
1246
repository_to = self.find_repository()
1248
# Found a branch, so we must have found a repository
1249
repository_to = br_to.repository
1251
push_result = PushResult()
1252
push_result.source_branch = source
1254
# We have a repository but no branch, copy the revisions, and then
1256
repository_to.fetch(source.repository, revision_id=revision_id)
1257
br_to = source.clone(self, revision_id=revision_id)
1258
if source.get_push_location() is None or remember:
1259
source.set_push_location(br_to.base)
1260
push_result.stacked_on = None
1261
push_result.branch_push_result = None
1262
push_result.old_revno = None
1263
push_result.old_revid = _mod_revision.NULL_REVISION
1264
push_result.target_branch = br_to
1265
push_result.master_branch = None
1266
push_result.workingtree_updated = False
1268
# We have successfully opened the branch, remember if necessary:
1269
if source.get_push_location() is None or remember:
1270
source.set_push_location(br_to.base)
1272
tree_to = self.open_workingtree()
1273
except errors.NotLocalUrl:
1274
push_result.branch_push_result = source.push(br_to,
1275
overwrite, stop_revision=revision_id)
1276
push_result.workingtree_updated = False
1277
except errors.NoWorkingTree:
1278
push_result.branch_push_result = source.push(br_to,
1279
overwrite, stop_revision=revision_id)
1280
push_result.workingtree_updated = None # Not applicable
1282
tree_to.lock_write()
1284
push_result.branch_push_result = source.push(
1285
tree_to.branch, overwrite, stop_revision=revision_id)
1289
push_result.workingtree_updated = True
1290
push_result.old_revno = push_result.branch_push_result.old_revno
1291
push_result.old_revid = push_result.branch_push_result.old_revid
1292
push_result.target_branch = \
1293
push_result.branch_push_result.target_branch
1297
class BzrDirHooks(hooks.Hooks):
1298
"""Hooks for BzrDir operations."""
1301
"""Create the default hooks."""
1302
hooks.Hooks.__init__(self)
1303
self.create_hook(hooks.HookPoint('pre_open',
1304
"Invoked before attempting to open a BzrDir with the transport "
1305
"that the open will use.", (1, 14), None))
1307
# install the default hooks
1308
BzrDir.hooks = BzrDirHooks()
1311
class BzrDirPreSplitOut(BzrDir):
1312
"""A common class for the all-in-one formats."""
1314
def __init__(self, _transport, _format):
1315
"""See BzrDir.__init__."""
1316
super(BzrDirPreSplitOut, self).__init__(_transport, _format)
1317
self._control_files = lockable_files.LockableFiles(
1318
self.get_branch_transport(None),
1319
self._format._lock_file_name,
1320
self._format._lock_class)
1322
def break_lock(self):
1323
"""Pre-splitout bzrdirs do not suffer from stale locks."""
1324
raise NotImplementedError(self.break_lock)
1326
def cloning_metadir(self, require_stacking=False):
1327
"""Produce a metadir suitable for cloning with."""
1328
if require_stacking:
1329
return format_registry.make_bzrdir('1.6')
1330
return self._format.__class__()
1332
def clone(self, url, revision_id=None, force_new_repo=False,
1333
preserve_stacking=False):
1334
"""See BzrDir.clone().
1336
force_new_repo has no effect, since this family of formats always
1337
require a new repository.
1338
preserve_stacking has no effect, since no source branch using this
1339
family of formats can be stacked, so there is no stacking to preserve.
1341
self._make_tail(url)
1342
result = self._format._initialize_for_clone(url)
1343
self.open_repository().clone(result, revision_id=revision_id)
1344
from_branch = self.open_branch()
1345
from_branch.clone(result, revision_id=revision_id)
1347
tree = self.open_workingtree()
1348
except errors.NotLocalUrl:
1349
# make a new one, this format always has to have one.
1350
result._init_workingtree()
1355
def create_branch(self):
1356
"""See BzrDir.create_branch."""
1357
return self._format.get_branch_format().initialize(self)
1359
def destroy_branch(self):
1360
"""See BzrDir.destroy_branch."""
1361
raise errors.UnsupportedOperation(self.destroy_branch, self)
1363
def create_repository(self, shared=False):
1364
"""See BzrDir.create_repository."""
1366
raise errors.IncompatibleFormat('shared repository', self._format)
1367
return self.open_repository()
1369
def destroy_repository(self):
1370
"""See BzrDir.destroy_repository."""
1371
raise errors.UnsupportedOperation(self.destroy_repository, self)
1373
def create_workingtree(self, revision_id=None, from_branch=None,
1374
accelerator_tree=None, hardlink=False):
1375
"""See BzrDir.create_workingtree."""
1376
# The workingtree is sometimes created when the bzrdir is created,
1377
# but not when cloning.
1379
# this looks buggy but is not -really-
1380
# because this format creates the workingtree when the bzrdir is
1382
# clone and sprout will have set the revision_id
1383
# and that will have set it for us, its only
1384
# specific uses of create_workingtree in isolation
1385
# that can do wonky stuff here, and that only
1386
# happens for creating checkouts, which cannot be
1387
# done on this format anyway. So - acceptable wart.
1389
warning("can't support hardlinked working trees in %r"
1392
result = self.open_workingtree(recommend_upgrade=False)
1393
except errors.NoSuchFile:
1394
result = self._init_workingtree()
1395
if revision_id is not None:
1396
if revision_id == _mod_revision.NULL_REVISION:
1397
result.set_parent_ids([])
1399
result.set_parent_ids([revision_id])
1402
def _init_workingtree(self):
1403
from bzrlib.workingtree import WorkingTreeFormat2
1405
return WorkingTreeFormat2().initialize(self)
1406
except errors.NotLocalUrl:
1407
# Even though we can't access the working tree, we need to
1408
# create its control files.
1409
return WorkingTreeFormat2()._stub_initialize_on_transport(
1410
self.transport, self._control_files._file_mode)
1412
def destroy_workingtree(self):
1413
"""See BzrDir.destroy_workingtree."""
1414
raise errors.UnsupportedOperation(self.destroy_workingtree, self)
1416
def destroy_workingtree_metadata(self):
1417
"""See BzrDir.destroy_workingtree_metadata."""
1418
raise errors.UnsupportedOperation(self.destroy_workingtree_metadata,
1421
def get_branch_transport(self, branch_format):
1422
"""See BzrDir.get_branch_transport()."""
1423
if branch_format is None:
1424
return self.transport
1426
branch_format.get_format_string()
1427
except NotImplementedError:
1428
return self.transport
1429
raise errors.IncompatibleFormat(branch_format, self._format)
1431
def get_repository_transport(self, repository_format):
1432
"""See BzrDir.get_repository_transport()."""
1433
if repository_format is None:
1434
return self.transport
1436
repository_format.get_format_string()
1437
except NotImplementedError:
1438
return self.transport
1439
raise errors.IncompatibleFormat(repository_format, self._format)
1441
def get_workingtree_transport(self, workingtree_format):
1442
"""See BzrDir.get_workingtree_transport()."""
1443
if workingtree_format is None:
1444
return self.transport
1446
workingtree_format.get_format_string()
1447
except NotImplementedError:
1448
return self.transport
1449
raise errors.IncompatibleFormat(workingtree_format, self._format)
1451
def needs_format_conversion(self, format=None):
1452
"""See BzrDir.needs_format_conversion()."""
1453
# if the format is not the same as the system default,
1454
# an upgrade is needed.
1456
symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
1457
% 'needs_format_conversion(format=None)')
1458
format = BzrDirFormat.get_default_format()
1459
return not isinstance(self._format, format.__class__)
1461
def open_branch(self, unsupported=False, ignore_fallbacks=False):
1462
"""See BzrDir.open_branch."""
1463
from bzrlib.branch import BzrBranchFormat4
1464
format = BzrBranchFormat4()
1465
self._check_supported(format, unsupported)
1466
return format.open(self, _found=True)
1468
def sprout(self, url, revision_id=None, force_new_repo=False,
1469
possible_transports=None, accelerator_tree=None,
1470
hardlink=False, stacked=False, create_tree_if_local=True,
1471
source_branch=None):
1472
"""See BzrDir.sprout()."""
1473
if source_branch is not None:
1474
my_branch = self.open_branch()
1475
if source_branch.base != my_branch.base:
1476
raise AssertionError(
1477
"source branch %r is not within %r with branch %r" %
1478
(source_branch, self, my_branch))
1480
raise errors.UnstackableBranchFormat(
1481
self._format, self.root_transport.base)
1482
if not create_tree_if_local:
1483
raise errors.MustHaveWorkingTree(
1484
self._format, self.root_transport.base)
1485
from bzrlib.workingtree import WorkingTreeFormat2
1486
self._make_tail(url)
1487
result = self._format._initialize_for_clone(url)
1489
self.open_repository().clone(result, revision_id=revision_id)
1490
except errors.NoRepositoryPresent:
1493
self.open_branch().sprout(result, revision_id=revision_id)
1494
except errors.NotBranchError:
1497
# we always want a working tree
1498
WorkingTreeFormat2().initialize(result,
1499
accelerator_tree=accelerator_tree,
1504
class BzrDir4(BzrDirPreSplitOut):
1505
"""A .bzr version 4 control object.
1507
This is a deprecated format and may be removed after sept 2006.
1510
def create_repository(self, shared=False):
1511
"""See BzrDir.create_repository."""
1512
return self._format.repository_format.initialize(self, shared)
1514
def needs_format_conversion(self, format=None):
1515
"""Format 4 dirs are always in need of conversion."""
1517
symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
1518
% 'needs_format_conversion(format=None)')
1521
def open_repository(self):
1522
"""See BzrDir.open_repository."""
1523
from bzrlib.repofmt.weaverepo import RepositoryFormat4
1524
return RepositoryFormat4().open(self, _found=True)
1527
class BzrDir5(BzrDirPreSplitOut):
1528
"""A .bzr version 5 control object.
1530
This is a deprecated format and may be removed after sept 2006.
1533
def open_repository(self):
1534
"""See BzrDir.open_repository."""
1535
from bzrlib.repofmt.weaverepo import RepositoryFormat5
1536
return RepositoryFormat5().open(self, _found=True)
1538
def open_workingtree(self, _unsupported=False,
1539
recommend_upgrade=True):
1540
"""See BzrDir.create_workingtree."""
1541
from bzrlib.workingtree import WorkingTreeFormat2
1542
wt_format = WorkingTreeFormat2()
1543
# we don't warn here about upgrades; that ought to be handled for the
1545
return wt_format.open(self, _found=True)
1548
class BzrDir6(BzrDirPreSplitOut):
1549
"""A .bzr version 6 control object.
1551
This is a deprecated format and may be removed after sept 2006.
1554
def open_repository(self):
1555
"""See BzrDir.open_repository."""
1556
from bzrlib.repofmt.weaverepo import RepositoryFormat6
1557
return RepositoryFormat6().open(self, _found=True)
1559
def open_workingtree(self, _unsupported=False,
1560
recommend_upgrade=True):
1561
"""See BzrDir.create_workingtree."""
1562
# we don't warn here about upgrades; that ought to be handled for the
1564
from bzrlib.workingtree import WorkingTreeFormat2
1565
return WorkingTreeFormat2().open(self, _found=True)
1568
class BzrDirMeta1(BzrDir):
1569
"""A .bzr meta version 1 control object.
1571
This is the first control object where the
1572
individual aspects are really split out: there are separate repository,
1573
workingtree and branch subdirectories and any subset of the three can be
1574
present within a BzrDir.
1577
def can_convert_format(self):
1578
"""See BzrDir.can_convert_format()."""
1581
def create_branch(self):
1582
"""See BzrDir.create_branch."""
1583
return self._format.get_branch_format().initialize(self)
1585
def destroy_branch(self):
1586
"""See BzrDir.create_branch."""
1587
self.transport.delete_tree('branch')
1589
def create_repository(self, shared=False):
1590
"""See BzrDir.create_repository."""
1591
return self._format.repository_format.initialize(self, shared)
1593
def destroy_repository(self):
1594
"""See BzrDir.destroy_repository."""
1595
self.transport.delete_tree('repository')
1597
def create_workingtree(self, revision_id=None, from_branch=None,
1598
accelerator_tree=None, hardlink=False):
1599
"""See BzrDir.create_workingtree."""
1600
return self._format.workingtree_format.initialize(
1601
self, revision_id, from_branch=from_branch,
1602
accelerator_tree=accelerator_tree, hardlink=hardlink)
1604
def destroy_workingtree(self):
1605
"""See BzrDir.destroy_workingtree."""
1606
wt = self.open_workingtree(recommend_upgrade=False)
1607
repository = wt.branch.repository
1608
empty = repository.revision_tree(_mod_revision.NULL_REVISION)
1609
wt.revert(old_tree=empty)
1610
self.destroy_workingtree_metadata()
1612
def destroy_workingtree_metadata(self):
1613
self.transport.delete_tree('checkout')
1615
def find_branch_format(self):
1616
"""Find the branch 'format' for this bzrdir.
1618
This might be a synthetic object for e.g. RemoteBranch and SVN.
1620
from bzrlib.branch import BranchFormat
1621
return BranchFormat.find_format(self)
1623
def _get_mkdir_mode(self):
1624
"""Figure out the mode to use when creating a bzrdir subdir."""
1625
temp_control = lockable_files.LockableFiles(self.transport, '',
1626
lockable_files.TransportLock)
1627
return temp_control._dir_mode
1629
def get_branch_reference(self):
1630
"""See BzrDir.get_branch_reference()."""
1631
from bzrlib.branch import BranchFormat
1632
format = BranchFormat.find_format(self)
1633
return format.get_reference(self)
1635
def get_branch_transport(self, branch_format):
1636
"""See BzrDir.get_branch_transport()."""
1637
if branch_format is None:
1638
return self.transport.clone('branch')
1640
branch_format.get_format_string()
1641
except NotImplementedError:
1642
raise errors.IncompatibleFormat(branch_format, self._format)
1644
self.transport.mkdir('branch', mode=self._get_mkdir_mode())
1645
except errors.FileExists:
1647
return self.transport.clone('branch')
1649
def get_repository_transport(self, repository_format):
1650
"""See BzrDir.get_repository_transport()."""
1651
if repository_format is None:
1652
return self.transport.clone('repository')
1654
repository_format.get_format_string()
1655
except NotImplementedError:
1656
raise errors.IncompatibleFormat(repository_format, self._format)
1658
self.transport.mkdir('repository', mode=self._get_mkdir_mode())
1659
except errors.FileExists:
1661
return self.transport.clone('repository')
1663
def get_workingtree_transport(self, workingtree_format):
1664
"""See BzrDir.get_workingtree_transport()."""
1665
if workingtree_format is None:
1666
return self.transport.clone('checkout')
1668
workingtree_format.get_format_string()
1669
except NotImplementedError:
1670
raise errors.IncompatibleFormat(workingtree_format, self._format)
1672
self.transport.mkdir('checkout', mode=self._get_mkdir_mode())
1673
except errors.FileExists:
1675
return self.transport.clone('checkout')
1677
def needs_format_conversion(self, format=None):
1678
"""See BzrDir.needs_format_conversion()."""
1680
symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
1681
% 'needs_format_conversion(format=None)')
1683
format = BzrDirFormat.get_default_format()
1684
if not isinstance(self._format, format.__class__):
1685
# it is not a meta dir format, conversion is needed.
1687
# we might want to push this down to the repository?
1689
if not isinstance(self.open_repository()._format,
1690
format.repository_format.__class__):
1691
# the repository needs an upgrade.
1693
except errors.NoRepositoryPresent:
1696
if not isinstance(self.open_branch()._format,
1697
format.get_branch_format().__class__):
1698
# the branch needs an upgrade.
1700
except errors.NotBranchError:
1703
my_wt = self.open_workingtree(recommend_upgrade=False)
1704
if not isinstance(my_wt._format,
1705
format.workingtree_format.__class__):
1706
# the workingtree needs an upgrade.
1708
except (errors.NoWorkingTree, errors.NotLocalUrl):
1712
def open_branch(self, unsupported=False, ignore_fallbacks=False):
1713
"""See BzrDir.open_branch."""
1714
format = self.find_branch_format()
1715
self._check_supported(format, unsupported)
1716
return format.open(self, _found=True, ignore_fallbacks=ignore_fallbacks)
1718
def open_repository(self, unsupported=False):
1719
"""See BzrDir.open_repository."""
1720
from bzrlib.repository import RepositoryFormat
1721
format = RepositoryFormat.find_format(self)
1722
self._check_supported(format, unsupported)
1723
return format.open(self, _found=True)
1725
def open_workingtree(self, unsupported=False,
1726
recommend_upgrade=True):
1727
"""See BzrDir.open_workingtree."""
1728
from bzrlib.workingtree import WorkingTreeFormat
1729
format = WorkingTreeFormat.find_format(self)
1730
self._check_supported(format, unsupported,
1732
basedir=self.root_transport.base)
1733
return format.open(self, _found=True)
1735
def _get_config(self):
1736
return config.TransportConfig(self.transport, 'control.conf')
1739
class BzrDirFormat(object):
1740
"""An encapsulation of the initialization and open routines for a format.
1742
Formats provide three things:
1743
* An initialization routine,
1747
Formats are placed in a dict by their format string for reference
1748
during bzrdir opening. These should be subclasses of BzrDirFormat
1751
Once a format is deprecated, just deprecate the initialize and open
1752
methods on the format class. Do not deprecate the object, as the
1753
object will be created every system load.
1756
_default_format = None
1757
"""The default format used for new .bzr dirs."""
1760
"""The known formats."""
1762
_control_formats = []
1763
"""The registered control formats - .bzr, ....
1765
This is a list of BzrDirFormat objects.
1768
_control_server_formats = []
1769
"""The registered control server formats, e.g. RemoteBzrDirs.
1771
This is a list of BzrDirFormat objects.
1774
_lock_file_name = 'branch-lock'
1776
# _lock_class must be set in subclasses to the lock type, typ.
1777
# TransportLock or LockDir
1780
def find_format(klass, transport, _server_formats=True):
1781
"""Return the format present at transport."""
1783
formats = klass._control_server_formats + klass._control_formats
1785
formats = klass._control_formats
1786
for format in formats:
1788
return format.probe_transport(transport)
1789
except errors.NotBranchError:
1790
# this format does not find a control dir here.
1792
raise errors.NotBranchError(path=transport.base)
1795
def probe_transport(klass, transport):
1796
"""Return the .bzrdir style format present in a directory."""
1798
format_string = transport.get(".bzr/branch-format").read()
1799
except errors.NoSuchFile:
1800
raise errors.NotBranchError(path=transport.base)
1803
return klass._formats[format_string]
1805
raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
1808
def get_default_format(klass):
1809
"""Return the current default format."""
1810
return klass._default_format
1812
def get_format_string(self):
1813
"""Return the ASCII format string that identifies this format."""
1814
raise NotImplementedError(self.get_format_string)
1816
def get_format_description(self):
1817
"""Return the short description for this format."""
1818
raise NotImplementedError(self.get_format_description)
1820
def get_converter(self, format=None):
1821
"""Return the converter to use to convert bzrdirs needing converts.
1823
This returns a bzrlib.bzrdir.Converter object.
1825
This should return the best upgrader to step this format towards the
1826
current default format. In the case of plugins we can/should provide
1827
some means for them to extend the range of returnable converters.
1829
:param format: Optional format to override the default format of the
1832
raise NotImplementedError(self.get_converter)
1834
def initialize(self, url, possible_transports=None):
1835
"""Create a bzr control dir at this url and return an opened copy.
1837
While not deprecated, this method is very specific and its use will
1838
lead to many round trips to setup a working environment. See
1839
initialize_on_transport_ex for a [nearly] all-in-one method.
1841
Subclasses should typically override initialize_on_transport
1842
instead of this method.
1844
return self.initialize_on_transport(get_transport(url,
1845
possible_transports))
1847
def initialize_on_transport(self, transport):
1848
"""Initialize a new bzrdir in the base directory of a Transport."""
1850
# can we hand off the request to the smart server rather than using
1852
client_medium = transport.get_smart_medium()
1853
except errors.NoSmartMedium:
1854
return self._initialize_on_transport_vfs(transport)
1856
# Current RPC's only know how to create bzr metadir1 instances, so
1857
# we still delegate to vfs methods if the requested format is not a
1859
if type(self) != BzrDirMetaFormat1:
1860
return self._initialize_on_transport_vfs(transport)
1861
remote_format = RemoteBzrDirFormat()
1862
self._supply_sub_formats_to(remote_format)
1863
return remote_format.initialize_on_transport(transport)
1865
def initialize_on_transport_ex(self, transport, use_existing_dir=False,
1866
create_prefix=False, force_new_repo=False, stacked_on=None,
1867
stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
1868
shared_repo=False, vfs_only=False):
1869
"""Create this format on transport.
1871
The directory to initialize will be created.
1873
:param force_new_repo: Do not use a shared repository for the target,
1874
even if one is available.
1875
:param create_prefix: Create any missing directories leading up to
1877
:param use_existing_dir: Use an existing directory if one exists.
1878
:param stacked_on: A url to stack any created branch on, None to follow
1879
any target stacking policy.
1880
:param stack_on_pwd: If stack_on is relative, the location it is
1882
:param repo_format_name: If non-None, a repository will be
1883
made-or-found. Should none be found, or if force_new_repo is True
1884
the repo_format_name is used to select the format of repository to
1886
:param make_working_trees: Control the setting of make_working_trees
1887
for a new shared repository when one is made. None to use whatever
1888
default the format has.
1889
:param shared_repo: Control whether made repositories are shared or
1891
:param vfs_only: If True do not attempt to use a smart server
1892
:return: repo, bzrdir, require_stacking, repository_policy. repo is
1893
None if none was created or found, bzrdir is always valid.
1894
require_stacking is the result of examining the stacked_on
1895
parameter and any stacking policy found for the target.
1898
# Try to hand off to a smart server
1900
client_medium = transport.get_smart_medium()
1901
except errors.NoSmartMedium:
1904
# TODO: lookup the local format from a server hint.
1905
remote_dir_format = RemoteBzrDirFormat()
1906
remote_dir_format._network_name = self.network_name()
1907
self._supply_sub_formats_to(remote_dir_format)
1908
return remote_dir_format.initialize_on_transport_ex(transport,
1909
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
1910
force_new_repo=force_new_repo, stacked_on=stacked_on,
1911
stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
1912
make_working_trees=make_working_trees, shared_repo=shared_repo)
1913
# XXX: Refactor the create_prefix/no_create_prefix code into a
1914
# common helper function
1915
# The destination may not exist - if so make it according to policy.
1916
def make_directory(transport):
1917
transport.mkdir('.')
1919
def redirected(transport, e, redirection_notice):
1920
note(redirection_notice)
1921
return transport._redirected_to(e.source, e.target)
1923
transport = do_catching_redirections(make_directory, transport,
1925
except errors.FileExists:
1926
if not use_existing_dir:
1928
except errors.NoSuchFile:
1929
if not create_prefix:
1931
transport.create_prefix()
1933
require_stacking = (stacked_on is not None)
1934
# Now the target directory exists, but doesn't have a .bzr
1935
# directory. So we need to create it, along with any work to create
1936
# all of the dependent branches, etc.
1938
result = self.initialize_on_transport(transport)
1939
if repo_format_name:
1941
# use a custom format
1942
result._format.repository_format = \
1943
repository.network_format_registry.get(repo_format_name)
1944
except AttributeError:
1945
# The format didn't permit it to be set.
1947
# A repository is desired, either in-place or shared.
1948
repository_policy = result.determine_repository_policy(
1949
force_new_repo, stacked_on, stack_on_pwd,
1950
require_stacking=require_stacking)
1951
result_repo, is_new_repo = repository_policy.acquire_repository(
1952
make_working_trees, shared_repo)
1953
if not require_stacking and repository_policy._require_stacking:
1954
require_stacking = True
1955
result._format.require_stacking()
1956
result_repo.lock_write()
1959
repository_policy = None
1960
return result_repo, result, require_stacking, repository_policy
1962
def _initialize_on_transport_vfs(self, transport):
1963
"""Initialize a new bzrdir using VFS calls.
1965
:param transport: The transport to create the .bzr directory in.
1968
# Since we are creating a .bzr directory, inherit the
1969
# mode from the root directory
1970
temp_control = lockable_files.LockableFiles(transport,
1971
'', lockable_files.TransportLock)
1972
temp_control._transport.mkdir('.bzr',
1973
# FIXME: RBC 20060121 don't peek under
1975
mode=temp_control._dir_mode)
1976
if sys.platform == 'win32' and isinstance(transport, local.LocalTransport):
1977
win32utils.set_file_attr_hidden(transport._abspath('.bzr'))
1978
file_mode = temp_control._file_mode
1980
bzrdir_transport = transport.clone('.bzr')
1981
utf8_files = [('README',
1982
"This is a Bazaar control directory.\n"
1983
"Do not change any files in this directory.\n"
1984
"See http://bazaar-vcs.org/ for more information about Bazaar.\n"),
1985
('branch-format', self.get_format_string()),
1987
# NB: no need to escape relative paths that are url safe.
1988
control_files = lockable_files.LockableFiles(bzrdir_transport,
1989
self._lock_file_name, self._lock_class)
1990
control_files.create_lock()
1991
control_files.lock_write()
1993
for (filename, content) in utf8_files:
1994
bzrdir_transport.put_bytes(filename, content,
1997
control_files.unlock()
1998
return self.open(transport, _found=True)
2000
def is_supported(self):
2001
"""Is this format supported?
2003
Supported formats must be initializable and openable.
2004
Unsupported formats may not support initialization or committing or
2005
some other features depending on the reason for not being supported.
2009
def network_name(self):
2010
"""A simple byte string uniquely identifying this format for RPC calls.
2012
Bzr control formats use thir disk format string to identify the format
2013
over the wire. Its possible that other control formats have more
2014
complex detection requirements, so we permit them to use any unique and
2015
immutable string they desire.
2017
raise NotImplementedError(self.network_name)
2019
def same_model(self, target_format):
2020
return (self.repository_format.rich_root_data ==
2021
target_format.rich_root_data)
2024
def known_formats(klass):
2025
"""Return all the known formats.
2027
Concrete formats should override _known_formats.
2029
# There is double indirection here to make sure that control
2030
# formats used by more than one dir format will only be probed
2031
# once. This can otherwise be quite expensive for remote connections.
2033
for format in klass._control_formats:
2034
result.update(format._known_formats())
2038
def _known_formats(klass):
2039
"""Return the known format instances for this control format."""
2040
return set(klass._formats.values())
2042
def open(self, transport, _found=False):
2043
"""Return an instance of this format for the dir transport points at.
2045
_found is a private parameter, do not use it.
2048
found_format = BzrDirFormat.find_format(transport)
2049
if not isinstance(found_format, self.__class__):
2050
raise AssertionError("%s was asked to open %s, but it seems to need "
2052
% (self, transport, found_format))
2053
# Allow subclasses - use the found format.
2054
self._supply_sub_formats_to(found_format)
2055
return found_format._open(transport)
2056
return self._open(transport)
2058
def _open(self, transport):
2059
"""Template method helper for opening BzrDirectories.
2061
This performs the actual open and any additional logic or parameter
2064
raise NotImplementedError(self._open)
2067
def register_format(klass, format):
2068
klass._formats[format.get_format_string()] = format
2069
# bzr native formats have a network name of their format string.
2070
network_format_registry.register(format.get_format_string(), format.__class__)
2073
def register_control_format(klass, format):
2074
"""Register a format that does not use '.bzr' for its control dir.
2076
TODO: This should be pulled up into a 'ControlDirFormat' base class
2077
which BzrDirFormat can inherit from, and renamed to register_format
2078
there. It has been done without that for now for simplicity of
2081
klass._control_formats.append(format)
2084
def register_control_server_format(klass, format):
2085
"""Register a control format for client-server environments.
2087
These formats will be tried before ones registered with
2088
register_control_format. This gives implementations that decide to the
2089
chance to grab it before anything looks at the contents of the format
2092
klass._control_server_formats.append(format)
2095
def _set_default_format(klass, format):
2096
"""Set default format (for testing behavior of defaults only)"""
2097
klass._default_format = format
2101
return self.get_format_description().rstrip()
2103
def _supply_sub_formats_to(self, other_format):
2104
"""Give other_format the same values for sub formats as this has.
2106
This method is expected to be used when parameterising a
2107
RemoteBzrDirFormat instance with the parameters from a
2108
BzrDirMetaFormat1 instance.
2110
:param other_format: other_format is a format which should be
2111
compatible with whatever sub formats are supported by self.
2116
def unregister_format(klass, format):
2117
del klass._formats[format.get_format_string()]
2120
def unregister_control_format(klass, format):
2121
klass._control_formats.remove(format)
2124
class BzrDirFormat4(BzrDirFormat):
2125
"""Bzr dir format 4.
2127
This format is a combined format for working tree, branch and repository.
2129
- Format 1 working trees [always]
2130
- Format 4 branches [always]
2131
- Format 4 repositories [always]
2133
This format is deprecated: it indexes texts using a text it which is
2134
removed in format 5; write support for this format has been removed.
2137
_lock_class = lockable_files.TransportLock
2139
def get_format_string(self):
2140
"""See BzrDirFormat.get_format_string()."""
2141
return "Bazaar-NG branch, format 0.0.4\n"
2143
def get_format_description(self):
2144
"""See BzrDirFormat.get_format_description()."""
2145
return "All-in-one format 4"
2147
def get_converter(self, format=None):
2148
"""See BzrDirFormat.get_converter()."""
2149
# there is one and only one upgrade path here.
2150
return ConvertBzrDir4To5()
2152
def initialize_on_transport(self, transport):
2153
"""Format 4 branches cannot be created."""
2154
raise errors.UninitializableFormat(self)
2156
def is_supported(self):
2157
"""Format 4 is not supported.
2159
It is not supported because the model changed from 4 to 5 and the
2160
conversion logic is expensive - so doing it on the fly was not
2165
def network_name(self):
2166
return self.get_format_string()
2168
def _open(self, transport):
2169
"""See BzrDirFormat._open."""
2170
return BzrDir4(transport, self)
2172
def __return_repository_format(self):
2173
"""Circular import protection."""
2174
from bzrlib.repofmt.weaverepo import RepositoryFormat4
2175
return RepositoryFormat4()
2176
repository_format = property(__return_repository_format)
2179
class BzrDirFormatAllInOne(BzrDirFormat):
2180
"""Common class for formats before meta-dirs."""
2182
def initialize_on_transport_ex(self, transport, use_existing_dir=False,
2183
create_prefix=False, force_new_repo=False, stacked_on=None,
2184
stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
2186
"""See BzrDirFormat.initialize_on_transport_ex."""
2187
require_stacking = (stacked_on is not None)
2188
# Format 5 cannot stack, but we've been asked to - actually init
2190
if require_stacking:
2191
format = BzrDirMetaFormat1()
2192
return format.initialize_on_transport_ex(transport,
2193
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
2194
force_new_repo=force_new_repo, stacked_on=stacked_on,
2195
stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
2196
make_working_trees=make_working_trees, shared_repo=shared_repo)
2197
return BzrDirFormat.initialize_on_transport_ex(self, transport,
2198
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
2199
force_new_repo=force_new_repo, stacked_on=stacked_on,
2200
stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
2201
make_working_trees=make_working_trees, shared_repo=shared_repo)
2204
class BzrDirFormat5(BzrDirFormatAllInOne):
2205
"""Bzr control format 5.
2207
This format is a combined format for working tree, branch and repository.
2209
- Format 2 working trees [always]
2210
- Format 4 branches [always]
2211
- Format 5 repositories [always]
2212
Unhashed stores in the repository.
2215
_lock_class = lockable_files.TransportLock
2217
def get_format_string(self):
2218
"""See BzrDirFormat.get_format_string()."""
2219
return "Bazaar-NG branch, format 5\n"
2221
def get_branch_format(self):
2222
from bzrlib import branch
2223
return branch.BzrBranchFormat4()
2225
def get_format_description(self):
2226
"""See BzrDirFormat.get_format_description()."""
2227
return "All-in-one format 5"
2229
def get_converter(self, format=None):
2230
"""See BzrDirFormat.get_converter()."""
2231
# there is one and only one upgrade path here.
2232
return ConvertBzrDir5To6()
2234
def _initialize_for_clone(self, url):
2235
return self.initialize_on_transport(get_transport(url), _cloning=True)
2237
def initialize_on_transport(self, transport, _cloning=False):
2238
"""Format 5 dirs always have working tree, branch and repository.
2240
Except when they are being cloned.
2242
from bzrlib.branch import BzrBranchFormat4
2243
from bzrlib.repofmt.weaverepo import RepositoryFormat5
2244
result = (super(BzrDirFormat5, self).initialize_on_transport(transport))
2245
RepositoryFormat5().initialize(result, _internal=True)
2247
branch = BzrBranchFormat4().initialize(result)
2248
result._init_workingtree()
2251
def network_name(self):
2252
return self.get_format_string()
2254
def _open(self, transport):
2255
"""See BzrDirFormat._open."""
2256
return BzrDir5(transport, self)
2258
def __return_repository_format(self):
2259
"""Circular import protection."""
2260
from bzrlib.repofmt.weaverepo import RepositoryFormat5
2261
return RepositoryFormat5()
2262
repository_format = property(__return_repository_format)
2265
class BzrDirFormat6(BzrDirFormatAllInOne):
2266
"""Bzr control format 6.
2268
This format is a combined format for working tree, branch and repository.
2270
- Format 2 working trees [always]
2271
- Format 4 branches [always]
2272
- Format 6 repositories [always]
2275
_lock_class = lockable_files.TransportLock
2277
def get_format_string(self):
2278
"""See BzrDirFormat.get_format_string()."""
2279
return "Bazaar-NG branch, format 6\n"
2281
def get_format_description(self):
2282
"""See BzrDirFormat.get_format_description()."""
2283
return "All-in-one format 6"
2285
def get_branch_format(self):
2286
from bzrlib import branch
2287
return branch.BzrBranchFormat4()
2289
def get_converter(self, format=None):
2290
"""See BzrDirFormat.get_converter()."""
2291
# there is one and only one upgrade path here.
2292
return ConvertBzrDir6ToMeta()
2294
def _initialize_for_clone(self, url):
2295
return self.initialize_on_transport(get_transport(url), _cloning=True)
2297
def initialize_on_transport(self, transport, _cloning=False):
2298
"""Format 6 dirs always have working tree, branch and repository.
2300
Except when they are being cloned.
2302
from bzrlib.branch import BzrBranchFormat4
2303
from bzrlib.repofmt.weaverepo import RepositoryFormat6
2304
result = super(BzrDirFormat6, self).initialize_on_transport(transport)
2305
RepositoryFormat6().initialize(result, _internal=True)
2307
branch = BzrBranchFormat4().initialize(result)
2308
result._init_workingtree()
2311
def network_name(self):
2312
return self.get_format_string()
2314
def _open(self, transport):
2315
"""See BzrDirFormat._open."""
2316
return BzrDir6(transport, self)
2318
def __return_repository_format(self):
2319
"""Circular import protection."""
2320
from bzrlib.repofmt.weaverepo import RepositoryFormat6
2321
return RepositoryFormat6()
2322
repository_format = property(__return_repository_format)
2325
class BzrDirMetaFormat1(BzrDirFormat):
2326
"""Bzr meta control format 1
2328
This is the first format with split out working tree, branch and repository
2331
- Format 3 working trees [optional]
2332
- Format 5 branches [optional]
2333
- Format 7 repositories [optional]
2336
_lock_class = lockdir.LockDir
2339
self._workingtree_format = None
2340
self._branch_format = None
2341
self._repository_format = None
2343
def __eq__(self, other):
2344
if other.__class__ is not self.__class__:
2346
if other.repository_format != self.repository_format:
2348
if other.workingtree_format != self.workingtree_format:
2352
def __ne__(self, other):
2353
return not self == other
2355
def get_branch_format(self):
2356
if self._branch_format is None:
2357
from bzrlib.branch import BranchFormat
2358
self._branch_format = BranchFormat.get_default_format()
2359
return self._branch_format
2361
def set_branch_format(self, format):
2362
self._branch_format = format
2364
def require_stacking(self, stack_on=None, possible_transports=None,
2366
"""We have a request to stack, try to ensure the formats support it.
2368
:param stack_on: If supplied, it is the URL to a branch that we want to
2369
stack on. Check to see if that format supports stacking before
2372
# Stacking is desired. requested by the target, but does the place it
2373
# points at support stacking? If it doesn't then we should
2374
# not implicitly upgrade. We check this here.
2375
new_repo_format = None
2376
new_branch_format = None
2378
# a bit of state for get_target_branch so that we don't try to open it
2379
# 2 times, for both repo *and* branch
2380
target = [None, False, None] # target_branch, checked, upgrade anyway
2381
def get_target_branch():
2383
# We've checked, don't check again
2385
if stack_on is None:
2386
# No target format, that means we want to force upgrading
2387
target[:] = [None, True, True]
2390
target_dir = BzrDir.open(stack_on,
2391
possible_transports=possible_transports)
2392
except errors.NotBranchError:
2393
# Nothing there, don't change formats
2394
target[:] = [None, True, False]
2396
except errors.JailBreak:
2397
# JailBreak, JFDI and upgrade anyway
2398
target[:] = [None, True, True]
2401
target_branch = target_dir.open_branch()
2402
except errors.NotBranchError:
2403
# No branch, don't upgrade formats
2404
target[:] = [None, True, False]
2406
target[:] = [target_branch, True, False]
2409
if (not _skip_repo and
2410
not self.repository_format.supports_external_lookups):
2411
# We need to upgrade the Repository.
2412
target_branch, _, do_upgrade = get_target_branch()
2413
if target_branch is None:
2414
# We don't have a target branch, should we upgrade anyway?
2416
# stack_on is inaccessible, JFDI.
2417
# TODO: bad monkey, hard-coded formats...
2418
if self.repository_format.rich_root_data:
2419
new_repo_format = pack_repo.RepositoryFormatKnitPack5RichRoot()
2421
new_repo_format = pack_repo.RepositoryFormatKnitPack5()
2423
# If the target already supports stacking, then we know the
2424
# project is already able to use stacking, so auto-upgrade
2426
new_repo_format = target_branch.repository._format
2427
if not new_repo_format.supports_external_lookups:
2428
# target doesn't, source doesn't, so don't auto upgrade
2430
new_repo_format = None
2431
if new_repo_format is not None:
2432
self.repository_format = new_repo_format
2433
note('Source repository format does not support stacking,'
2434
' using format:\n %s',
2435
new_repo_format.get_format_description())
2437
if not self.get_branch_format().supports_stacking():
2438
# We just checked the repo, now lets check if we need to
2439
# upgrade the branch format
2440
target_branch, _, do_upgrade = get_target_branch()
2441
if target_branch is None:
2443
# TODO: bad monkey, hard-coded formats...
2444
new_branch_format = branch.BzrBranchFormat7()
2446
new_branch_format = target_branch._format
2447
if not new_branch_format.supports_stacking():
2448
new_branch_format = None
2449
if new_branch_format is not None:
2450
# Does support stacking, use its format.
2451
self.set_branch_format(new_branch_format)
2452
note('Source branch format does not support stacking,'
2453
' using format:\n %s',
2454
new_branch_format.get_format_description())
2456
def get_converter(self, format=None):
2457
"""See BzrDirFormat.get_converter()."""
2459
format = BzrDirFormat.get_default_format()
2460
if not isinstance(self, format.__class__):
2461
# converting away from metadir is not implemented
2462
raise NotImplementedError(self.get_converter)
2463
return ConvertMetaToMeta(format)
2465
def get_format_string(self):
2466
"""See BzrDirFormat.get_format_string()."""
2467
return "Bazaar-NG meta directory, format 1\n"
2469
def get_format_description(self):
2470
"""See BzrDirFormat.get_format_description()."""
2471
return "Meta directory format 1"
2473
def network_name(self):
2474
return self.get_format_string()
2476
def _open(self, transport):
2477
"""See BzrDirFormat._open."""
2478
# Create a new format instance because otherwise initialisation of new
2479
# metadirs share the global default format object leading to alias
2481
format = BzrDirMetaFormat1()
2482
self._supply_sub_formats_to(format)
2483
return BzrDirMeta1(transport, format)
2485
def __return_repository_format(self):
2486
"""Circular import protection."""
2487
if self._repository_format:
2488
return self._repository_format
2489
from bzrlib.repository import RepositoryFormat
2490
return RepositoryFormat.get_default_format()
2492
def _set_repository_format(self, value):
2493
"""Allow changing the repository format for metadir formats."""
2494
self._repository_format = value
2496
repository_format = property(__return_repository_format,
2497
_set_repository_format)
2499
def _supply_sub_formats_to(self, other_format):
2500
"""Give other_format the same values for sub formats as this has.
2502
This method is expected to be used when parameterising a
2503
RemoteBzrDirFormat instance with the parameters from a
2504
BzrDirMetaFormat1 instance.
2506
:param other_format: other_format is a format which should be
2507
compatible with whatever sub formats are supported by self.
2510
if getattr(self, '_repository_format', None) is not None:
2511
other_format.repository_format = self.repository_format
2512
if self._branch_format is not None:
2513
other_format._branch_format = self._branch_format
2514
if self._workingtree_format is not None:
2515
other_format.workingtree_format = self.workingtree_format
2517
def __get_workingtree_format(self):
2518
if self._workingtree_format is None:
2519
from bzrlib.workingtree import WorkingTreeFormat
2520
self._workingtree_format = WorkingTreeFormat.get_default_format()
2521
return self._workingtree_format
2523
def __set_workingtree_format(self, wt_format):
2524
self._workingtree_format = wt_format
2526
workingtree_format = property(__get_workingtree_format,
2527
__set_workingtree_format)
2530
network_format_registry = registry.FormatRegistry()
2531
"""Registry of formats indexed by their network name.
2533
The network name for a BzrDirFormat is an identifier that can be used when
2534
referring to formats with smart server operations. See
2535
BzrDirFormat.network_name() for more detail.
2539
# Register bzr control format
2540
BzrDirFormat.register_control_format(BzrDirFormat)
2542
# Register bzr formats
2543
BzrDirFormat.register_format(BzrDirFormat4())
2544
BzrDirFormat.register_format(BzrDirFormat5())
2545
BzrDirFormat.register_format(BzrDirFormat6())
2546
__default_format = BzrDirMetaFormat1()
2547
BzrDirFormat.register_format(__default_format)
2548
BzrDirFormat._default_format = __default_format
2551
class Converter(object):
2552
"""Converts a disk format object from one format to another."""
2554
def convert(self, to_convert, pb):
2555
"""Perform the conversion of to_convert, giving feedback via pb.
2557
:param to_convert: The disk object to convert.
2558
:param pb: a progress bar to use for progress information.
2561
def step(self, message):
2562
"""Update the pb by a step."""
2564
self.pb.update(message, self.count, self.total)
2567
class ConvertBzrDir4To5(Converter):
2568
"""Converts format 4 bzr dirs to format 5."""
2571
super(ConvertBzrDir4To5, self).__init__()
2572
self.converted_revs = set()
2573
self.absent_revisions = set()
2577
def convert(self, to_convert, pb):
2578
"""See Converter.convert()."""
2579
self.bzrdir = to_convert
2581
self.pb.note('starting upgrade from format 4 to 5')
2582
if isinstance(self.bzrdir.transport, local.LocalTransport):
2583
self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
2584
self._convert_to_weaves()
2585
return BzrDir.open(self.bzrdir.root_transport.base)
2587
def _convert_to_weaves(self):
2588
self.pb.note('note: upgrade may be faster if all store files are ungzipped first')
2591
stat = self.bzrdir.transport.stat('weaves')
2592
if not S_ISDIR(stat.st_mode):
2593
self.bzrdir.transport.delete('weaves')
2594
self.bzrdir.transport.mkdir('weaves')
2595
except errors.NoSuchFile:
2596
self.bzrdir.transport.mkdir('weaves')
2597
# deliberately not a WeaveFile as we want to build it up slowly.
2598
self.inv_weave = Weave('inventory')
2599
# holds in-memory weaves for all files
2600
self.text_weaves = {}
2601
self.bzrdir.transport.delete('branch-format')
2602
self.branch = self.bzrdir.open_branch()
2603
self._convert_working_inv()
2604
rev_history = self.branch.revision_history()
2605
# to_read is a stack holding the revisions we still need to process;
2606
# appending to it adds new highest-priority revisions
2607
self.known_revisions = set(rev_history)
2608
self.to_read = rev_history[-1:]
2610
rev_id = self.to_read.pop()
2611
if (rev_id not in self.revisions
2612
and rev_id not in self.absent_revisions):
2613
self._load_one_rev(rev_id)
2615
to_import = self._make_order()
2616
for i, rev_id in enumerate(to_import):
2617
self.pb.update('converting revision', i, len(to_import))
2618
self._convert_one_rev(rev_id)
2620
self._write_all_weaves()
2621
self._write_all_revs()
2622
self.pb.note('upgraded to weaves:')
2623
self.pb.note(' %6d revisions and inventories', len(self.revisions))
2624
self.pb.note(' %6d revisions not present', len(self.absent_revisions))
2625
self.pb.note(' %6d texts', self.text_count)
2626
self._cleanup_spare_files_after_format4()
2627
self.branch._transport.put_bytes(
2629
BzrDirFormat5().get_format_string(),
2630
mode=self.bzrdir._get_file_mode())
2632
def _cleanup_spare_files_after_format4(self):
2633
# FIXME working tree upgrade foo.
2634
for n in 'merged-patches', 'pending-merged-patches':
2636
## assert os.path.getsize(p) == 0
2637
self.bzrdir.transport.delete(n)
2638
except errors.NoSuchFile:
2640
self.bzrdir.transport.delete_tree('inventory-store')
2641
self.bzrdir.transport.delete_tree('text-store')
2643
def _convert_working_inv(self):
2644
inv = xml4.serializer_v4.read_inventory(
2645
self.branch._transport.get('inventory'))
2646
new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv, working=True)
2647
self.branch._transport.put_bytes('inventory', new_inv_xml,
2648
mode=self.bzrdir._get_file_mode())
2650
def _write_all_weaves(self):
2651
controlweaves = WeaveStore(self.bzrdir.transport, prefixed=False)
2652
weave_transport = self.bzrdir.transport.clone('weaves')
2653
weaves = WeaveStore(weave_transport, prefixed=False)
2654
transaction = WriteTransaction()
2658
for file_id, file_weave in self.text_weaves.items():
2659
self.pb.update('writing weave', i, len(self.text_weaves))
2660
weaves._put_weave(file_id, file_weave, transaction)
2662
self.pb.update('inventory', 0, 1)
2663
controlweaves._put_weave('inventory', self.inv_weave, transaction)
2664
self.pb.update('inventory', 1, 1)
2668
def _write_all_revs(self):
2669
"""Write all revisions out in new form."""
2670
self.bzrdir.transport.delete_tree('revision-store')
2671
self.bzrdir.transport.mkdir('revision-store')
2672
revision_transport = self.bzrdir.transport.clone('revision-store')
2674
from bzrlib.xml5 import serializer_v5
2675
from bzrlib.repofmt.weaverepo import RevisionTextStore
2676
revision_store = RevisionTextStore(revision_transport,
2677
serializer_v5, False, versionedfile.PrefixMapper(),
2678
lambda:True, lambda:True)
2680
for i, rev_id in enumerate(self.converted_revs):
2681
self.pb.update('write revision', i, len(self.converted_revs))
2682
text = serializer_v5.write_revision_to_string(
2683
self.revisions[rev_id])
2685
revision_store.add_lines(key, None, osutils.split_lines(text))
2689
def _load_one_rev(self, rev_id):
2690
"""Load a revision object into memory.
2692
Any parents not either loaded or abandoned get queued to be
2694
self.pb.update('loading revision',
2695
len(self.revisions),
2696
len(self.known_revisions))
2697
if not self.branch.repository.has_revision(rev_id):
2699
self.pb.note('revision {%s} not present in branch; '
2700
'will be converted as a ghost',
2702
self.absent_revisions.add(rev_id)
2704
rev = self.branch.repository.get_revision(rev_id)
2705
for parent_id in rev.parent_ids:
2706
self.known_revisions.add(parent_id)
2707
self.to_read.append(parent_id)
2708
self.revisions[rev_id] = rev
2710
def _load_old_inventory(self, rev_id):
2711
old_inv_xml = self.branch.repository.inventory_store.get(rev_id).read()
2712
inv = xml4.serializer_v4.read_inventory_from_string(old_inv_xml)
2713
inv.revision_id = rev_id
2714
rev = self.revisions[rev_id]
2717
def _load_updated_inventory(self, rev_id):
2718
inv_xml = self.inv_weave.get_text(rev_id)
2719
inv = xml5.serializer_v5.read_inventory_from_string(inv_xml, rev_id)
2722
def _convert_one_rev(self, rev_id):
2723
"""Convert revision and all referenced objects to new format."""
2724
rev = self.revisions[rev_id]
2725
inv = self._load_old_inventory(rev_id)
2726
present_parents = [p for p in rev.parent_ids
2727
if p not in self.absent_revisions]
2728
self._convert_revision_contents(rev, inv, present_parents)
2729
self._store_new_inv(rev, inv, present_parents)
2730
self.converted_revs.add(rev_id)
2732
def _store_new_inv(self, rev, inv, present_parents):
2733
new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
2734
new_inv_sha1 = sha_string(new_inv_xml)
2735
self.inv_weave.add_lines(rev.revision_id,
2737
new_inv_xml.splitlines(True))
2738
rev.inventory_sha1 = new_inv_sha1
2740
def _convert_revision_contents(self, rev, inv, present_parents):
2741
"""Convert all the files within a revision.
2743
Also upgrade the inventory to refer to the text revision ids."""
2744
rev_id = rev.revision_id
2745
mutter('converting texts of revision {%s}',
2747
parent_invs = map(self._load_updated_inventory, present_parents)
2748
entries = inv.iter_entries()
2750
for path, ie in entries:
2751
self._convert_file_version(rev, ie, parent_invs)
2753
def _convert_file_version(self, rev, ie, parent_invs):
2754
"""Convert one version of one file.
2756
The file needs to be added into the weave if it is a merge
2757
of >=2 parents or if it's changed from its parent.
2759
file_id = ie.file_id
2760
rev_id = rev.revision_id
2761
w = self.text_weaves.get(file_id)
2764
self.text_weaves[file_id] = w
2765
text_changed = False
2766
parent_candiate_entries = ie.parent_candidates(parent_invs)
2767
heads = graph.Graph(self).heads(parent_candiate_entries.keys())
2768
# XXX: Note that this is unordered - and this is tolerable because
2769
# the previous code was also unordered.
2770
previous_entries = dict((head, parent_candiate_entries[head]) for head
2772
self.snapshot_ie(previous_entries, ie, w, rev_id)
2775
def get_parent_map(self, revision_ids):
2776
"""See graph.StackedParentsProvider.get_parent_map"""
2777
return dict((revision_id, self.revisions[revision_id])
2778
for revision_id in revision_ids
2779
if revision_id in self.revisions)
2781
def snapshot_ie(self, previous_revisions, ie, w, rev_id):
2782
# TODO: convert this logic, which is ~= snapshot to
2783
# a call to:. This needs the path figured out. rather than a work_tree
2784
# a v4 revision_tree can be given, or something that looks enough like
2785
# one to give the file content to the entry if it needs it.
2786
# and we need something that looks like a weave store for snapshot to
2788
#ie.snapshot(rev, PATH, previous_revisions, REVISION_TREE, InMemoryWeaveStore(self.text_weaves))
2789
if len(previous_revisions) == 1:
2790
previous_ie = previous_revisions.values()[0]
2791
if ie._unchanged(previous_ie):
2792
ie.revision = previous_ie.revision
2795
text = self.branch.repository._text_store.get(ie.text_id)
2796
file_lines = text.readlines()
2797
w.add_lines(rev_id, previous_revisions, file_lines)
2798
self.text_count += 1
2800
w.add_lines(rev_id, previous_revisions, [])
2801
ie.revision = rev_id
2803
def _make_order(self):
2804
"""Return a suitable order for importing revisions.
2806
The order must be such that an revision is imported after all
2807
its (present) parents.
2809
todo = set(self.revisions.keys())
2810
done = self.absent_revisions.copy()
2813
# scan through looking for a revision whose parents
2815
for rev_id in sorted(list(todo)):
2816
rev = self.revisions[rev_id]
2817
parent_ids = set(rev.parent_ids)
2818
if parent_ids.issubset(done):
2819
# can take this one now
2820
order.append(rev_id)
2826
class ConvertBzrDir5To6(Converter):
2827
"""Converts format 5 bzr dirs to format 6."""
2829
def convert(self, to_convert, pb):
2830
"""See Converter.convert()."""
2831
self.bzrdir = to_convert
2833
self.pb.note('starting upgrade from format 5 to 6')
2834
self._convert_to_prefixed()
2835
return BzrDir.open(self.bzrdir.root_transport.base)
2837
def _convert_to_prefixed(self):
2838
from bzrlib.store import TransportStore
2839
self.bzrdir.transport.delete('branch-format')
2840
for store_name in ["weaves", "revision-store"]:
2841
self.pb.note("adding prefixes to %s" % store_name)
2842
store_transport = self.bzrdir.transport.clone(store_name)
2843
store = TransportStore(store_transport, prefixed=True)
2844
for urlfilename in store_transport.list_dir('.'):
2845
filename = urlutils.unescape(urlfilename)
2846
if (filename.endswith(".weave") or
2847
filename.endswith(".gz") or
2848
filename.endswith(".sig")):
2849
file_id, suffix = os.path.splitext(filename)
2853
new_name = store._mapper.map((file_id,)) + suffix
2854
# FIXME keep track of the dirs made RBC 20060121
2856
store_transport.move(filename, new_name)
2857
except errors.NoSuchFile: # catches missing dirs strangely enough
2858
store_transport.mkdir(osutils.dirname(new_name))
2859
store_transport.move(filename, new_name)
2860
self.bzrdir.transport.put_bytes(
2862
BzrDirFormat6().get_format_string(),
2863
mode=self.bzrdir._get_file_mode())
2866
class ConvertBzrDir6ToMeta(Converter):
2867
"""Converts format 6 bzr dirs to metadirs."""
2869
def convert(self, to_convert, pb):
2870
"""See Converter.convert()."""
2871
from bzrlib.repofmt.weaverepo import RepositoryFormat7
2872
from bzrlib.branch import BzrBranchFormat5
2873
self.bzrdir = to_convert
2876
self.total = 20 # the steps we know about
2877
self.garbage_inventories = []
2878
self.dir_mode = self.bzrdir._get_dir_mode()
2879
self.file_mode = self.bzrdir._get_file_mode()
2881
self.pb.note('starting upgrade from format 6 to metadir')
2882
self.bzrdir.transport.put_bytes(
2884
"Converting to format 6",
2885
mode=self.file_mode)
2886
# its faster to move specific files around than to open and use the apis...
2887
# first off, nuke ancestry.weave, it was never used.
2889
self.step('Removing ancestry.weave')
2890
self.bzrdir.transport.delete('ancestry.weave')
2891
except errors.NoSuchFile:
2893
# find out whats there
2894
self.step('Finding branch files')
2895
last_revision = self.bzrdir.open_branch().last_revision()
2896
bzrcontents = self.bzrdir.transport.list_dir('.')
2897
for name in bzrcontents:
2898
if name.startswith('basis-inventory.'):
2899
self.garbage_inventories.append(name)
2900
# create new directories for repository, working tree and branch
2901
repository_names = [('inventory.weave', True),
2902
('revision-store', True),
2904
self.step('Upgrading repository ')
2905
self.bzrdir.transport.mkdir('repository', mode=self.dir_mode)
2906
self.make_lock('repository')
2907
# we hard code the formats here because we are converting into
2908
# the meta format. The meta format upgrader can take this to a
2909
# future format within each component.
2910
self.put_format('repository', RepositoryFormat7())
2911
for entry in repository_names:
2912
self.move_entry('repository', entry)
2914
self.step('Upgrading branch ')
2915
self.bzrdir.transport.mkdir('branch', mode=self.dir_mode)
2916
self.make_lock('branch')
2917
self.put_format('branch', BzrBranchFormat5())
2918
branch_files = [('revision-history', True),
2919
('branch-name', True),
2921
for entry in branch_files:
2922
self.move_entry('branch', entry)
2924
checkout_files = [('pending-merges', True),
2925
('inventory', True),
2926
('stat-cache', False)]
2927
# If a mandatory checkout file is not present, the branch does not have
2928
# a functional checkout. Do not create a checkout in the converted
2930
for name, mandatory in checkout_files:
2931
if mandatory and name not in bzrcontents:
2932
has_checkout = False
2936
if not has_checkout:
2937
self.pb.note('No working tree.')
2938
# If some checkout files are there, we may as well get rid of them.
2939
for name, mandatory in checkout_files:
2940
if name in bzrcontents:
2941
self.bzrdir.transport.delete(name)
2943
from bzrlib.workingtree import WorkingTreeFormat3
2944
self.step('Upgrading working tree')
2945
self.bzrdir.transport.mkdir('checkout', mode=self.dir_mode)
2946
self.make_lock('checkout')
2948
'checkout', WorkingTreeFormat3())
2949
self.bzrdir.transport.delete_multi(
2950
self.garbage_inventories, self.pb)
2951
for entry in checkout_files:
2952
self.move_entry('checkout', entry)
2953
if last_revision is not None:
2954
self.bzrdir.transport.put_bytes(
2955
'checkout/last-revision', last_revision)
2956
self.bzrdir.transport.put_bytes(
2958
BzrDirMetaFormat1().get_format_string(),
2959
mode=self.file_mode)
2960
return BzrDir.open(self.bzrdir.root_transport.base)
2962
def make_lock(self, name):
2963
"""Make a lock for the new control dir name."""
2964
self.step('Make %s lock' % name)
2965
ld = lockdir.LockDir(self.bzrdir.transport,
2967
file_modebits=self.file_mode,
2968
dir_modebits=self.dir_mode)
2971
def move_entry(self, new_dir, entry):
2972
"""Move then entry name into new_dir."""
2974
mandatory = entry[1]
2975
self.step('Moving %s' % name)
2977
self.bzrdir.transport.move(name, '%s/%s' % (new_dir, name))
2978
except errors.NoSuchFile:
2982
def put_format(self, dirname, format):
2983
self.bzrdir.transport.put_bytes('%s/format' % dirname,
2984
format.get_format_string(),
2988
class ConvertMetaToMeta(Converter):
2989
"""Converts the components of metadirs."""
2991
def __init__(self, target_format):
2992
"""Create a metadir to metadir converter.
2994
:param target_format: The final metadir format that is desired.
2996
self.target_format = target_format
2998
def convert(self, to_convert, pb):
2999
"""See Converter.convert()."""
3000
self.bzrdir = to_convert
3004
self.step('checking repository format')
3006
repo = self.bzrdir.open_repository()
3007
except errors.NoRepositoryPresent:
3010
if not isinstance(repo._format, self.target_format.repository_format.__class__):
3011
from bzrlib.repository import CopyConverter
3012
self.pb.note('starting repository conversion')
3013
converter = CopyConverter(self.target_format.repository_format)
3014
converter.convert(repo, pb)
3016
branch = self.bzrdir.open_branch()
3017
except errors.NotBranchError:
3020
# TODO: conversions of Branch and Tree should be done by
3021
# InterXFormat lookups/some sort of registry.
3022
# Avoid circular imports
3023
from bzrlib import branch as _mod_branch
3024
old = branch._format.__class__
3025
new = self.target_format.get_branch_format().__class__
3027
if (old == _mod_branch.BzrBranchFormat5 and
3028
new in (_mod_branch.BzrBranchFormat6,
3029
_mod_branch.BzrBranchFormat7,
3030
_mod_branch.BzrBranchFormat8)):
3031
branch_converter = _mod_branch.Converter5to6()
3032
elif (old == _mod_branch.BzrBranchFormat6 and
3033
new in (_mod_branch.BzrBranchFormat7,
3034
_mod_branch.BzrBranchFormat8)):
3035
branch_converter = _mod_branch.Converter6to7()
3036
elif (old == _mod_branch.BzrBranchFormat7 and
3037
new is _mod_branch.BzrBranchFormat8):
3038
branch_converter = _mod_branch.Converter7to8()
3040
raise errors.BadConversionTarget("No converter", new)
3041
branch_converter.convert(branch)
3042
branch = self.bzrdir.open_branch()
3043
old = branch._format.__class__
3045
tree = self.bzrdir.open_workingtree(recommend_upgrade=False)
3046
except (errors.NoWorkingTree, errors.NotLocalUrl):
3049
# TODO: conversions of Branch and Tree should be done by
3050
# InterXFormat lookups
3051
if (isinstance(tree, workingtree.WorkingTree3) and
3052
not isinstance(tree, workingtree_4.DirStateWorkingTree) and
3053
isinstance(self.target_format.workingtree_format,
3054
workingtree_4.DirStateWorkingTreeFormat)):
3055
workingtree_4.Converter3to4().convert(tree)
3056
if (isinstance(tree, workingtree_4.DirStateWorkingTree) and
3057
not isinstance(tree, workingtree_4.WorkingTree5) and
3058
isinstance(self.target_format.workingtree_format,
3059
workingtree_4.WorkingTreeFormat5)):
3060
workingtree_4.Converter4to5().convert(tree)
3061
if (isinstance(tree, workingtree_4.DirStateWorkingTree) and
3062
not isinstance(tree, workingtree_4.WorkingTree6) and
3063
isinstance(self.target_format.workingtree_format,
3064
workingtree_4.WorkingTreeFormat6)):
3065
workingtree_4.Converter4or5to6().convert(tree)
3069
# This is not in remote.py because it's relatively small, and needs to be
3070
# registered. Putting it in remote.py creates a circular import problem.
3071
# we can make it a lazy object if the control formats is turned into something
3073
class RemoteBzrDirFormat(BzrDirMetaFormat1):
3074
"""Format representing bzrdirs accessed via a smart server"""
3077
BzrDirMetaFormat1.__init__(self)
3078
self._network_name = None
3080
def get_format_description(self):
3081
return 'bzr remote bzrdir'
3083
def get_format_string(self):
3084
raise NotImplementedError(self.get_format_string)
3086
def network_name(self):
3087
if self._network_name:
3088
return self._network_name
3090
raise AssertionError("No network name set.")
3093
def probe_transport(klass, transport):
3094
"""Return a RemoteBzrDirFormat object if it looks possible."""
3096
medium = transport.get_smart_medium()
3097
except (NotImplementedError, AttributeError,
3098
errors.TransportNotPossible, errors.NoSmartMedium,
3099
errors.SmartProtocolError):
3100
# no smart server, so not a branch for this format type.
3101
raise errors.NotBranchError(path=transport.base)
3103
# Decline to open it if the server doesn't support our required
3104
# version (3) so that the VFS-based transport will do it.
3105
if medium.should_probe():
3107
server_version = medium.protocol_version()
3108
except errors.SmartProtocolError:
3109
# Apparently there's no usable smart server there, even though
3110
# the medium supports the smart protocol.
3111
raise errors.NotBranchError(path=transport.base)
3112
if server_version != '2':
3113
raise errors.NotBranchError(path=transport.base)
3116
def initialize_on_transport(self, transport):
3118
# hand off the request to the smart server
3119
client_medium = transport.get_smart_medium()
3120
except errors.NoSmartMedium:
3121
# TODO: lookup the local format from a server hint.
3122
local_dir_format = BzrDirMetaFormat1()
3123
return local_dir_format.initialize_on_transport(transport)
3124
client = _SmartClient(client_medium)
3125
path = client.remote_path_from_transport(transport)
3127
response = client.call('BzrDirFormat.initialize', path)
3128
except errors.ErrorFromSmartServer, err:
3129
remote._translate_error(err, path=path)
3130
if response[0] != 'ok':
3131
raise errors.SmartProtocolError('unexpected response code %s' % (response,))
3132
format = RemoteBzrDirFormat()
3133
self._supply_sub_formats_to(format)
3134
return remote.RemoteBzrDir(transport, format)
3136
def parse_NoneTrueFalse(self, arg):
3143
raise AssertionError("invalid arg %r" % arg)
3145
def _serialize_NoneTrueFalse(self, arg):
3152
def _serialize_NoneString(self, arg):
3155
def initialize_on_transport_ex(self, transport, use_existing_dir=False,
3156
create_prefix=False, force_new_repo=False, stacked_on=None,
3157
stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
3160
# hand off the request to the smart server
3161
client_medium = transport.get_smart_medium()
3162
except errors.NoSmartMedium:
3165
# Decline to open it if the server doesn't support our required
3166
# version (3) so that the VFS-based transport will do it.
3167
if client_medium.should_probe():
3169
server_version = client_medium.protocol_version()
3170
if server_version != '2':
3174
except errors.SmartProtocolError:
3175
# Apparently there's no usable smart server there, even though
3176
# the medium supports the smart protocol.
3181
client = _SmartClient(client_medium)
3182
path = client.remote_path_from_transport(transport)
3183
if client_medium._is_remote_before((1, 16)):
3186
# TODO: lookup the local format from a server hint.
3187
local_dir_format = BzrDirMetaFormat1()
3188
self._supply_sub_formats_to(local_dir_format)
3189
return local_dir_format.initialize_on_transport_ex(transport,
3190
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
3191
force_new_repo=force_new_repo, stacked_on=stacked_on,
3192
stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
3193
make_working_trees=make_working_trees, shared_repo=shared_repo,
3195
return self._initialize_on_transport_ex_rpc(client, path, transport,
3196
use_existing_dir, create_prefix, force_new_repo, stacked_on,
3197
stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
3199
def _initialize_on_transport_ex_rpc(self, client, path, transport,
3200
use_existing_dir, create_prefix, force_new_repo, stacked_on,
3201
stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
3203
args.append(self._serialize_NoneTrueFalse(use_existing_dir))
3204
args.append(self._serialize_NoneTrueFalse(create_prefix))
3205
args.append(self._serialize_NoneTrueFalse(force_new_repo))
3206
args.append(self._serialize_NoneString(stacked_on))
3207
# stack_on_pwd is often/usually our transport
3210
stack_on_pwd = transport.relpath(stack_on_pwd)
3211
if not stack_on_pwd:
3213
except errors.PathNotChild:
3215
args.append(self._serialize_NoneString(stack_on_pwd))
3216
args.append(self._serialize_NoneString(repo_format_name))
3217
args.append(self._serialize_NoneTrueFalse(make_working_trees))
3218
args.append(self._serialize_NoneTrueFalse(shared_repo))
3219
if self._network_name is None:
3220
self._network_name = \
3221
BzrDirFormat.get_default_format().network_name()
3223
response = client.call('BzrDirFormat.initialize_ex_1.16',
3224
self.network_name(), path, *args)
3225
except errors.UnknownSmartMethod:
3226
client._medium._remember_remote_is_before((1,16))
3227
local_dir_format = BzrDirMetaFormat1()
3228
self._supply_sub_formats_to(local_dir_format)
3229
return local_dir_format.initialize_on_transport_ex(transport,
3230
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
3231
force_new_repo=force_new_repo, stacked_on=stacked_on,
3232
stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
3233
make_working_trees=make_working_trees, shared_repo=shared_repo,
3235
except errors.ErrorFromSmartServer, err:
3236
remote._translate_error(err, path=path)
3237
repo_path = response[0]
3238
bzrdir_name = response[6]
3239
require_stacking = response[7]
3240
require_stacking = self.parse_NoneTrueFalse(require_stacking)
3241
format = RemoteBzrDirFormat()
3242
format._network_name = bzrdir_name
3243
self._supply_sub_formats_to(format)
3244
bzrdir = remote.RemoteBzrDir(transport, format, _client=client)
3246
repo_format = remote.response_tuple_to_repo_format(response[1:])
3247
if repo_path == '.':
3250
repo_bzrdir_format = RemoteBzrDirFormat()
3251
repo_bzrdir_format._network_name = response[5]
3252
repo_bzr = remote.RemoteBzrDir(transport.clone(repo_path),
3256
final_stack = response[8] or None
3257
final_stack_pwd = response[9] or None
3259
final_stack_pwd = urlutils.join(
3260
transport.base, final_stack_pwd)
3261
remote_repo = remote.RemoteRepository(repo_bzr, repo_format)
3262
if len(response) > 10:
3263
# Updated server verb that locks remotely.
3264
repo_lock_token = response[10] or None
3265
remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
3267
remote_repo.dont_leave_lock_in_place()
3269
remote_repo.lock_write()
3270
policy = UseExistingRepository(remote_repo, final_stack,
3271
final_stack_pwd, require_stacking)
3272
policy.acquire_repository()
3276
bzrdir._format.set_branch_format(self.get_branch_format())
3277
if require_stacking:
3278
# The repo has already been created, but we need to make sure that
3279
# we'll make a stackable branch.
3280
bzrdir._format.require_stacking(_skip_repo=True)
3281
return remote_repo, bzrdir, require_stacking, policy
3283
def _open(self, transport):
3284
return remote.RemoteBzrDir(transport, self)
3286
def __eq__(self, other):
3287
if not isinstance(other, RemoteBzrDirFormat):
3289
return self.get_format_description() == other.get_format_description()
3291
def __return_repository_format(self):
3292
# Always return a RemoteRepositoryFormat object, but if a specific bzr
3293
# repository format has been asked for, tell the RemoteRepositoryFormat
3294
# that it should use that for init() etc.
3295
result = remote.RemoteRepositoryFormat()
3296
custom_format = getattr(self, '_repository_format', None)
3298
if isinstance(custom_format, remote.RemoteRepositoryFormat):
3299
return custom_format
3301
# We will use the custom format to create repositories over the
3302
# wire; expose its details like rich_root_data for code to
3304
result._custom_format = custom_format
3307
def get_branch_format(self):
3308
result = BzrDirMetaFormat1.get_branch_format(self)
3309
if not isinstance(result, remote.RemoteBranchFormat):
3310
new_result = remote.RemoteBranchFormat()
3311
new_result._custom_format = result
3313
self.set_branch_format(new_result)
3317
repository_format = property(__return_repository_format,
3318
BzrDirMetaFormat1._set_repository_format) #.im_func)
3321
BzrDirFormat.register_control_server_format(RemoteBzrDirFormat)
3324
class BzrDirFormatInfo(object):
3326
def __init__(self, native, deprecated, hidden, experimental):
3327
self.deprecated = deprecated
3328
self.native = native
3329
self.hidden = hidden
3330
self.experimental = experimental
3333
class BzrDirFormatRegistry(registry.Registry):
3334
"""Registry of user-selectable BzrDir subformats.
3336
Differs from BzrDirFormat._control_formats in that it provides sub-formats,
3337
e.g. BzrDirMeta1 with weave repository. Also, it's more user-oriented.
3341
"""Create a BzrDirFormatRegistry."""
3342
self._aliases = set()
3343
self._registration_order = list()
3344
super(BzrDirFormatRegistry, self).__init__()
3347
"""Return a set of the format names which are aliases."""
3348
return frozenset(self._aliases)
3350
def register_metadir(self, key,
3351
repository_format, help, native=True, deprecated=False,
3357
"""Register a metadir subformat.
3359
These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
3360
by the Repository/Branch/WorkingTreeformats.
3362
:param repository_format: The fully-qualified repository format class
3364
:param branch_format: Fully-qualified branch format class name as
3366
:param tree_format: Fully-qualified tree format class name as
3369
# This should be expanded to support setting WorkingTree and Branch
3370
# formats, once BzrDirMetaFormat1 supports that.
3371
def _load(full_name):
3372
mod_name, factory_name = full_name.rsplit('.', 1)
3374
mod = __import__(mod_name, globals(), locals(),
3376
except ImportError, e:
3377
raise ImportError('failed to load %s: %s' % (full_name, e))
3379
factory = getattr(mod, factory_name)
3380
except AttributeError:
3381
raise AttributeError('no factory %s in module %r'
3386
bd = BzrDirMetaFormat1()
3387
if branch_format is not None:
3388
bd.set_branch_format(_load(branch_format))
3389
if tree_format is not None:
3390
bd.workingtree_format = _load(tree_format)
3391
if repository_format is not None:
3392
bd.repository_format = _load(repository_format)
3394
self.register(key, helper, help, native, deprecated, hidden,
3395
experimental, alias)
3397
def register(self, key, factory, help, native=True, deprecated=False,
3398
hidden=False, experimental=False, alias=False):
3399
"""Register a BzrDirFormat factory.
3401
The factory must be a callable that takes one parameter: the key.
3402
It must produce an instance of the BzrDirFormat when called.
3404
This function mainly exists to prevent the info object from being
3407
registry.Registry.register(self, key, factory, help,
3408
BzrDirFormatInfo(native, deprecated, hidden, experimental))
3410
self._aliases.add(key)
3411
self._registration_order.append(key)
3413
def register_lazy(self, key, module_name, member_name, help, native=True,
3414
deprecated=False, hidden=False, experimental=False, alias=False):
3415
registry.Registry.register_lazy(self, key, module_name, member_name,
3416
help, BzrDirFormatInfo(native, deprecated, hidden, experimental))
3418
self._aliases.add(key)
3419
self._registration_order.append(key)
3421
def set_default(self, key):
3422
"""Set the 'default' key to be a clone of the supplied key.
3424
This method must be called once and only once.
3426
registry.Registry.register(self, 'default', self.get(key),
3427
self.get_help(key), info=self.get_info(key))
3428
self._aliases.add('default')
3430
def set_default_repository(self, key):
3431
"""Set the FormatRegistry default and Repository default.
3433
This is a transitional method while Repository.set_default_format
3436
if 'default' in self:
3437
self.remove('default')
3438
self.set_default(key)
3439
format = self.get('default')()
3441
def make_bzrdir(self, key):
3442
return self.get(key)()
3444
def help_topic(self, topic):
3446
default_realkey = None
3447
default_help = self.get_help('default')
3449
for key in self._registration_order:
3450
if key == 'default':
3452
help = self.get_help(key)
3453
if help == default_help:
3454
default_realkey = key
3456
help_pairs.append((key, help))
3458
def wrapped(key, help, info):
3460
help = '(native) ' + help
3461
return ':%s:\n%s\n\n' % (key,
3462
textwrap.fill(help, initial_indent=' ',
3463
subsequent_indent=' ',
3464
break_long_words=False))
3465
if default_realkey is not None:
3466
output += wrapped(default_realkey, '(default) %s' % default_help,
3467
self.get_info('default'))
3468
deprecated_pairs = []
3469
experimental_pairs = []
3470
for key, help in help_pairs:
3471
info = self.get_info(key)
3474
elif info.deprecated:
3475
deprecated_pairs.append((key, help))
3476
elif info.experimental:
3477
experimental_pairs.append((key, help))
3479
output += wrapped(key, help, info)
3480
output += "\nSee ``bzr help formats`` for more about storage formats."
3482
if len(experimental_pairs) > 0:
3483
other_output += "Experimental formats are shown below.\n\n"
3484
for key, help in experimental_pairs:
3485
info = self.get_info(key)
3486
other_output += wrapped(key, help, info)
3489
"No experimental formats are available.\n\n"
3490
if len(deprecated_pairs) > 0:
3491
other_output += "\nDeprecated formats are shown below.\n\n"
3492
for key, help in deprecated_pairs:
3493
info = self.get_info(key)
3494
other_output += wrapped(key, help, info)
3497
"\nNo deprecated formats are available.\n\n"
3499
"\nSee ``bzr help formats`` for more about storage formats."
3501
if topic == 'other-formats':
3507
class RepositoryAcquisitionPolicy(object):
3508
"""Abstract base class for repository acquisition policies.
3510
A repository acquisition policy decides how a BzrDir acquires a repository
3511
for a branch that is being created. The most basic policy decision is
3512
whether to create a new repository or use an existing one.
3514
def __init__(self, stack_on, stack_on_pwd, require_stacking):
3517
:param stack_on: A location to stack on
3518
:param stack_on_pwd: If stack_on is relative, the location it is
3520
:param require_stacking: If True, it is a failure to not stack.
3522
self._stack_on = stack_on
3523
self._stack_on_pwd = stack_on_pwd
3524
self._require_stacking = require_stacking
3526
def configure_branch(self, branch):
3527
"""Apply any configuration data from this policy to the branch.
3529
Default implementation sets repository stacking.
3531
if self._stack_on is None:
3533
if self._stack_on_pwd is None:
3534
stack_on = self._stack_on
3537
stack_on = urlutils.rebase_url(self._stack_on,
3539
branch.bzrdir.root_transport.base)
3540
except errors.InvalidRebaseURLs:
3541
stack_on = self._get_full_stack_on()
3543
branch.set_stacked_on_url(stack_on)
3544
except (errors.UnstackableBranchFormat,
3545
errors.UnstackableRepositoryFormat):
3546
if self._require_stacking:
3549
def _get_full_stack_on(self):
3550
"""Get a fully-qualified URL for the stack_on location."""
3551
if self._stack_on is None:
3553
if self._stack_on_pwd is None:
3554
return self._stack_on
3556
return urlutils.join(self._stack_on_pwd, self._stack_on)
3558
def _add_fallback(self, repository, possible_transports=None):
3559
"""Add a fallback to the supplied repository, if stacking is set."""
3560
stack_on = self._get_full_stack_on()
3561
if stack_on is None:
3564
stacked_dir = BzrDir.open(stack_on,
3565
possible_transports=possible_transports)
3566
except errors.JailBreak:
3567
# We keep the stacking details, but we are in the server code so
3568
# actually stacking is not needed.
3571
stacked_repo = stacked_dir.open_branch().repository
3572
except errors.NotBranchError:
3573
stacked_repo = stacked_dir.open_repository()
3575
repository.add_fallback_repository(stacked_repo)
3576
except errors.UnstackableRepositoryFormat:
3577
if self._require_stacking:
3580
self._require_stacking = True
3582
def acquire_repository(self, make_working_trees=None, shared=False):
3583
"""Acquire a repository for this bzrdir.
3585
Implementations may create a new repository or use a pre-exising
3587
:param make_working_trees: If creating a repository, set
3588
make_working_trees to this value (if non-None)
3589
:param shared: If creating a repository, make it shared if True
3590
:return: A repository, is_new_flag (True if the repository was
3593
raise NotImplemented(RepositoryAcquisitionPolicy.acquire_repository)
3596
class CreateRepository(RepositoryAcquisitionPolicy):
3597
"""A policy of creating a new repository"""
3599
def __init__(self, bzrdir, stack_on=None, stack_on_pwd=None,
3600
require_stacking=False):
3603
:param bzrdir: The bzrdir to create the repository on.
3604
:param stack_on: A location to stack on
3605
:param stack_on_pwd: If stack_on is relative, the location it is
3608
RepositoryAcquisitionPolicy.__init__(self, stack_on, stack_on_pwd,
3610
self._bzrdir = bzrdir
3612
def acquire_repository(self, make_working_trees=None, shared=False):
3613
"""Implementation of RepositoryAcquisitionPolicy.acquire_repository
3615
Creates the desired repository in the bzrdir we already have.
3617
stack_on = self._get_full_stack_on()
3619
format = self._bzrdir._format
3620
format.require_stacking(stack_on=stack_on,
3621
possible_transports=[self._bzrdir.root_transport])
3622
if not self._require_stacking:
3623
# We have picked up automatic stacking somewhere.
3624
note('Using default stacking branch %s at %s', self._stack_on,
3626
repository = self._bzrdir.create_repository(shared=shared)
3627
self._add_fallback(repository,
3628
possible_transports=[self._bzrdir.transport])
3629
if make_working_trees is not None:
3630
repository.set_make_working_trees(make_working_trees)
3631
return repository, True
3634
class UseExistingRepository(RepositoryAcquisitionPolicy):
3635
"""A policy of reusing an existing repository"""
3637
def __init__(self, repository, stack_on=None, stack_on_pwd=None,
3638
require_stacking=False):
3641
:param repository: The repository to use.
3642
:param stack_on: A location to stack on
3643
:param stack_on_pwd: If stack_on is relative, the location it is
3646
RepositoryAcquisitionPolicy.__init__(self, stack_on, stack_on_pwd,
3648
self._repository = repository
3650
def acquire_repository(self, make_working_trees=None, shared=False):
3651
"""Implementation of RepositoryAcquisitionPolicy.acquire_repository
3653
Returns an existing repository to use.
3655
self._add_fallback(self._repository,
3656
possible_transports=[self._repository.bzrdir.transport])
3657
return self._repository, False
3660
# Please register new formats after old formats so that formats
3661
# appear in chronological order and format descriptions can build
3663
format_registry = BzrDirFormatRegistry()
3664
# The pre-0.8 formats have their repository format network name registered in
3665
# repository.py. MetaDir formats have their repository format network name
3666
# inferred from their disk format string.
3667
format_registry.register('weave', BzrDirFormat6,
3668
'Pre-0.8 format. Slower than knit and does not'
3669
' support checkouts or shared repositories.',
3671
format_registry.register_metadir('metaweave',
3672
'bzrlib.repofmt.weaverepo.RepositoryFormat7',
3673
'Transitional format in 0.8. Slower than knit.',
3674
branch_format='bzrlib.branch.BzrBranchFormat5',
3675
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3677
format_registry.register_metadir('knit',
3678
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3679
'Format using knits. Recommended for interoperation with bzr <= 0.14.',
3680
branch_format='bzrlib.branch.BzrBranchFormat5',
3681
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3683
format_registry.register_metadir('dirstate',
3684
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3685
help='New in 0.15: Fast local operations. Compatible with bzr 0.8 and '
3686
'above when accessed over the network.',
3687
branch_format='bzrlib.branch.BzrBranchFormat5',
3688
# this uses bzrlib.workingtree.WorkingTreeFormat4 because importing
3689
# directly from workingtree_4 triggers a circular import.
3690
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3692
format_registry.register_metadir('dirstate-tags',
3693
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3694
help='New in 0.15: Fast local operations and improved scaling for '
3695
'network operations. Additionally adds support for tags.'
3696
' Incompatible with bzr < 0.15.',
3697
branch_format='bzrlib.branch.BzrBranchFormat6',
3698
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3700
format_registry.register_metadir('rich-root',
3701
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit4',
3702
help='New in 1.0. Better handling of tree roots. Incompatible with'
3704
branch_format='bzrlib.branch.BzrBranchFormat6',
3705
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3707
format_registry.register_metadir('dirstate-with-subtree',
3708
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
3709
help='New in 0.15: Fast local operations and improved scaling for '
3710
'network operations. Additionally adds support for versioning nested '
3711
'bzr branches. Incompatible with bzr < 0.15.',
3712
branch_format='bzrlib.branch.BzrBranchFormat6',
3713
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3717
format_registry.register_metadir('pack-0.92',
3718
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack1',
3719
help='New in 0.92: Pack-based format with data compatible with '
3720
'dirstate-tags format repositories. Interoperates with '
3721
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3722
'Previously called knitpack-experimental. '
3723
'For more information, see '
3724
'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
3725
branch_format='bzrlib.branch.BzrBranchFormat6',
3726
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3728
format_registry.register_metadir('pack-0.92-subtree',
3729
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack3',
3730
help='New in 0.92: Pack-based format with data compatible with '
3731
'dirstate-with-subtree format repositories. Interoperates with '
3732
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3733
'Previously called knitpack-experimental. '
3734
'For more information, see '
3735
'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
3736
branch_format='bzrlib.branch.BzrBranchFormat6',
3737
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3741
format_registry.register_metadir('rich-root-pack',
3742
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack4',
3743
help='New in 1.0: A variant of pack-0.92 that supports rich-root data '
3744
'(needed for bzr-svn and bzr-git).',
3745
branch_format='bzrlib.branch.BzrBranchFormat6',
3746
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3748
format_registry.register_metadir('1.6',
3749
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5',
3750
help='A format that allows a branch to indicate that there is another '
3751
'(stacked) repository that should be used to access data that is '
3752
'not present locally.',
3753
branch_format='bzrlib.branch.BzrBranchFormat7',
3754
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3756
format_registry.register_metadir('1.6.1-rich-root',
3757
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5RichRoot',
3758
help='A variant of 1.6 that supports rich-root data '
3759
'(needed for bzr-svn and bzr-git).',
3760
branch_format='bzrlib.branch.BzrBranchFormat7',
3761
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3763
format_registry.register_metadir('1.9',
3764
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3765
help='A repository format using B+tree indexes. These indexes '
3766
'are smaller in size, have smarter caching and provide faster '
3767
'performance for most operations.',
3768
branch_format='bzrlib.branch.BzrBranchFormat7',
3769
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3771
format_registry.register_metadir('1.9-rich-root',
3772
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3773
help='A variant of 1.9 that supports rich-root data '
3774
'(needed for bzr-svn and bzr-git).',
3775
branch_format='bzrlib.branch.BzrBranchFormat7',
3776
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3778
format_registry.register_metadir('1.14',
3779
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3780
help='A working-tree format that supports content filtering.',
3781
branch_format='bzrlib.branch.BzrBranchFormat7',
3782
tree_format='bzrlib.workingtree.WorkingTreeFormat5',
3784
format_registry.register_metadir('1.14-rich-root',
3785
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3786
help='A variant of 1.14 that supports rich-root data '
3787
'(needed for bzr-svn and bzr-git).',
3788
branch_format='bzrlib.branch.BzrBranchFormat7',
3789
tree_format='bzrlib.workingtree.WorkingTreeFormat5',
3791
# The following un-numbered 'development' formats should always just be aliases.
3792
format_registry.register_metadir('development-rich-root',
3793
'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK1',
3794
help='Current development format. Supports rich roots. Can convert data '
3795
'to and from rich-root-pack (and anything compatible with '
3796
'rich-root-pack) format repositories. Repositories and branches in '
3797
'this format can only be read by bzr.dev. Please read '
3798
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3800
branch_format='bzrlib.branch.BzrBranchFormat7',
3801
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3805
format_registry.register_metadir('development-subtree',
3806
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
3807
help='Current development format, subtree variant. Can convert data to and '
3808
'from pack-0.92-subtree (and anything compatible with '
3809
'pack-0.92-subtree) format repositories. Repositories and branches in '
3810
'this format can only be read by bzr.dev. Please read '
3811
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3813
branch_format='bzrlib.branch.BzrBranchFormat7',
3814
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3816
alias=False, # Restore to being an alias when an actual development subtree format is added
3817
# This current non-alias status is simply because we did not introduce a
3818
# chk based subtree format.
3821
# And the development formats above will have aliased one of the following:
3822
format_registry.register_metadir('development6-rich-root',
3823
'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK1',
3824
help='pack-1.9 with 255-way hashed CHK inv, group compress, rich roots '
3826
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3828
branch_format='bzrlib.branch.BzrBranchFormat7',
3829
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3834
format_registry.register_metadir('development7-rich-root',
3835
'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK2',
3836
help='pack-1.9 with 255-way hashed CHK inv, bencode revision, group compress, '
3837
'rich roots. Please read '
3838
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3840
branch_format='bzrlib.branch.BzrBranchFormat7',
3841
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3846
format_registry.register_metadir('2a',
3847
'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
3848
help='First format for bzr 2.0 series.\n'
3849
'Uses group-compress storage.\n'
3850
'Provides rich roots which are a one-way transition.\n',
3851
# 'storage in packs, 255-way hashed CHK inventory, bencode revision, group compress, '
3852
# 'rich roots. Supported by bzr 1.16 and later.',
3853
branch_format='bzrlib.branch.BzrBranchFormat7',
3854
tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3858
# The following format should be an alias for the rich root equivalent
3859
# of the default format
3860
format_registry.register_metadir('default-rich-root',
3861
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack4',
3862
help='Default format, rich root variant. (needed for bzr-svn and bzr-git).',
3863
branch_format='bzrlib.branch.BzrBranchFormat6',
3864
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3867
# The current format that is made on 'bzr init'.
3868
format_registry.set_default('pack-0.92')
added
removed
bzrlib/bzrdir.py
