84
118
"""Return true if this bzrdir is one whose format we can convert from."""
121
def check_conversion_target(self, target_format):
122
target_repo_format = target_format.repository_format
123
source_repo_format = self._format.repository_format
124
source_repo_format.check_conversion_target(target_repo_format)
88
def _check_supported(format, allow_unsupported):
89
"""Check whether format is a supported format.
91
If allow_unsupported is True, this is a no-op.
127
def _check_supported(format, allow_unsupported,
128
recommend_upgrade=True,
130
"""Give an error or warning on old formats.
132
:param format: may be any kind of format - workingtree, branch,
135
:param allow_unsupported: If true, allow opening
136
formats that are strongly deprecated, and which may
137
have limited functionality.
139
:param recommend_upgrade: If true (default), warn
140
the user through the ui object that they may wish
141
to upgrade the object.
143
# TODO: perhaps move this into a base Format class; it's not BzrDir
144
# specific. mbp 20070323
93
145
if not allow_unsupported and not format.is_supported():
94
146
# see open_downlevel to open legacy branches.
95
raise errors.UnsupportedFormatError(
96
'sorry, format %s not supported' % format,
97
['use a different bzr version',
98
'or remove the .bzr directory'
99
' and "bzr init" again'])
147
raise errors.UnsupportedFormatError(format=format)
148
if recommend_upgrade \
149
and getattr(format, 'upgrade_recommended', False):
150
ui.ui_factory.recommend_upgrade(
151
format.get_format_description(),
101
def clone(self, url, revision_id=None, basis=None, force_new_repo=False):
154
def clone(self, url, revision_id=None, force_new_repo=False,
155
preserve_stacking=False):
102
156
"""Clone this bzrdir and its contents to url verbatim.
104
If urls last component does not exist, it will be created.
106
if revision_id is not None, then the clone operation may tune
107
itself to download less data.
108
:param force_new_repo: Do not use a shared repository for the target
109
even if one is available.
112
basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
113
result = self._format.initialize(url)
158
:param url: The url create the clone at. If url's last component does
159
not exist, it will be created.
160
:param revision_id: The tip revision-id to use for any branch or
161
working tree. If not None, then the clone operation may tune
162
itself to download less data.
163
:param force_new_repo: Do not use a shared repository for the target
164
even if one is available.
165
:param preserve_stacking: When cloning a stacked branch, stack the
166
new branch on top of the other branch's stacked-on branch.
168
return self.clone_on_transport(get_transport(url),
169
revision_id=revision_id,
170
force_new_repo=force_new_repo,
171
preserve_stacking=preserve_stacking)
173
def clone_on_transport(self, transport, revision_id=None,
174
force_new_repo=False, preserve_stacking=False,
176
"""Clone this bzrdir and its contents to transport verbatim.
178
:param transport: The transport for the location to produce the clone
179
at. If the target directory does not exist, it will be created.
180
:param revision_id: The tip revision-id to use for any branch or
181
working tree. If not None, then the clone operation may tune
182
itself to download less data.
183
:param force_new_repo: Do not use a shared repository for the target,
184
even if one is available.
185
:param preserve_stacking: When cloning a stacked branch, stack the
186
new branch on top of the other branch's stacked-on branch.
188
transport.ensure_base()
189
require_stacking = (stacked_on is not None)
190
metadir = self.cloning_metadir(require_stacking)
191
result = metadir.initialize_on_transport(transport)
192
repository_policy = None
115
194
local_repo = self.find_repository()
116
195
except errors.NoRepositoryPresent:
117
196
local_repo = None
198
local_branch = self.open_branch()
199
except errors.NotBranchError:
202
# enable fallbacks when branch is not a branch reference
203
if local_branch.repository.has_same_location(local_repo):
204
local_repo = local_branch.repository
205
if preserve_stacking:
207
stacked_on = local_branch.get_stacked_on_url()
208
except (errors.UnstackableBranchFormat,
209
errors.UnstackableRepositoryFormat,
119
214
# may need to copy content in
121
result_repo = local_repo.clone(
123
revision_id=revision_id,
125
result_repo.set_make_working_trees(local_repo.make_working_trees())
128
result_repo = result.find_repository()
129
# fetch content this dir needs.
131
# XXX FIXME RBC 20060214 need tests for this when the basis
133
result_repo.fetch(basis_repo, revision_id=revision_id)
134
result_repo.fetch(local_repo, revision_id=revision_id)
135
except errors.NoRepositoryPresent:
136
# needed to make one anyway.
137
result_repo = local_repo.clone(
139
revision_id=revision_id,
141
result_repo.set_make_working_trees(local_repo.make_working_trees())
215
repository_policy = result.determine_repository_policy(
216
force_new_repo, stacked_on, self.root_transport.base,
217
require_stacking=require_stacking)
218
make_working_trees = local_repo.make_working_trees()
219
result_repo = repository_policy.acquire_repository(
220
make_working_trees, local_repo.is_shared())
221
if not require_stacking and repository_policy._require_stacking:
222
require_stacking = True
223
result._format.require_stacking()
224
result_repo.fetch(local_repo, revision_id=revision_id)
142
227
# 1 if there is a branch present
143
228
# make sure its content is available in the target repository
146
self.open_branch().clone(result, revision_id=revision_id)
147
except errors.NotBranchError:
150
self.open_workingtree().clone(result, basis=basis_tree)
151
except (errors.NoWorkingTree, errors.NotLocalUrl):
230
if local_branch is not None:
231
result_branch = local_branch.clone(result, revision_id=revision_id)
232
if repository_policy is not None:
233
repository_policy.configure_branch(result_branch)
234
if result_repo is None or result_repo.make_working_trees():
236
self.open_workingtree().clone(result)
237
except (errors.NoWorkingTree, errors.NotLocalUrl):
155
def _get_basis_components(self, basis):
156
"""Retrieve the basis components that are available at basis."""
158
return None, None, None
160
basis_tree = basis.open_workingtree()
161
basis_branch = basis_tree.branch
162
basis_repo = basis_branch.repository
163
except (errors.NoWorkingTree, errors.NotLocalUrl):
166
basis_branch = basis.open_branch()
167
basis_repo = basis_branch.repository
168
except errors.NotBranchError:
171
basis_repo = basis.open_repository()
172
except errors.NoRepositoryPresent:
174
return basis_repo, basis_branch, basis_tree
176
241
# TODO: This should be given a Transport, and should chdir up; otherwise
177
242
# this will open a new connection.
178
243
def _make_tail(self, url):
179
head, tail = urlutils.split(url)
180
if tail and tail != '.':
181
t = bzrlib.transport.get_transport(head)
184
except errors.FileExists:
244
t = get_transport(url)
187
# TODO: Should take a Transport
189
def create(cls, base):
248
def create(cls, base, format=None, possible_transports=None):
190
249
"""Create a new BzrDir at the url 'base'.
192
This will call the current default formats initialize with base
193
as the only parameter.
195
If you need a specific format, consider creating an instance
196
of that and calling initialize().
251
:param format: If supplied, the format of branch to create. If not
252
supplied, the default is used.
253
:param possible_transports: If supplied, a list of transports that
254
can be reused to share a remote connection.
198
256
if cls is not BzrDir:
199
raise AssertionError("BzrDir.create always creates the default format, "
200
"not one of %r" % cls)
201
head, tail = urlutils.split(base)
202
if tail and tail != '.':
203
t = bzrlib.transport.get_transport(head)
206
except errors.FileExists:
208
return BzrDirFormat.get_default_format().initialize(safe_unicode(base))
257
raise AssertionError("BzrDir.create always creates the default"
258
" format, not one of %r" % cls)
259
t = get_transport(base, possible_transports)
262
format = BzrDirFormat.get_default_format()
263
return format.initialize_on_transport(t)
266
def find_bzrdirs(transport, evaluate=None, list_current=None):
267
"""Find bzrdirs recursively from current location.
269
This is intended primarily as a building block for more sophisticated
270
functionality, like finding trees under a directory, or finding
271
branches that use a given repository.
272
:param evaluate: An optional callable that yields recurse, value,
273
where recurse controls whether this bzrdir is recursed into
274
and value is the value to yield. By default, all bzrdirs
275
are recursed into, and the return value is the bzrdir.
276
:param list_current: if supplied, use this function to list the current
277
directory, instead of Transport.list_dir
278
:return: a generator of found bzrdirs, or whatever evaluate returns.
280
if list_current is None:
281
def list_current(transport):
282
return transport.list_dir('')
284
def evaluate(bzrdir):
287
pending = [transport]
288
while len(pending) > 0:
289
current_transport = pending.pop()
292
bzrdir = BzrDir.open_from_transport(current_transport)
293
except errors.NotBranchError:
296
recurse, value = evaluate(bzrdir)
299
subdirs = list_current(current_transport)
300
except errors.NoSuchFile:
303
for subdir in sorted(subdirs, reverse=True):
304
pending.append(current_transport.clone(subdir))
307
def find_branches(transport):
308
"""Find all branches under a transport.
310
This will find all branches below the transport, including branches
311
inside other branches. Where possible, it will use
312
Repository.find_branches.
314
To list all the branches that use a particular Repository, see
315
Repository.find_branches
317
def evaluate(bzrdir):
319
repository = bzrdir.open_repository()
320
except errors.NoRepositoryPresent:
323
return False, (None, repository)
325
branch = bzrdir.open_branch()
326
except errors.NotBranchError:
327
return True, (None, None)
329
return True, (branch, None)
331
for branch, repo in BzrDir.find_bzrdirs(transport, evaluate=evaluate):
333
branches.extend(repo.find_branches())
334
if branch is not None:
335
branches.append(branch)
338
def destroy_repository(self):
339
"""Destroy the repository in this BzrDir"""
340
raise NotImplementedError(self.destroy_repository)
210
342
def create_branch(self):
211
343
"""Create a branch in this BzrDir.
213
The bzrdirs format will control what branch format is created.
345
The bzrdir's format will control what branch format is created.
214
346
For more control see BranchFormatXX.create(a_bzrdir).
216
348
raise NotImplementedError(self.create_branch)
350
def destroy_branch(self):
351
"""Destroy the branch in this BzrDir"""
352
raise NotImplementedError(self.destroy_branch)
219
def create_branch_and_repo(base, force_new_repo=False):
355
def create_branch_and_repo(base, force_new_repo=False, format=None):
220
356
"""Create a new BzrDir, Branch and Repository at the url 'base'.
222
This will use the current default BzrDirFormat, and use whatever
358
This will use the current default BzrDirFormat unless one is
359
specified, and use whatever
223
360
repository format that that uses via bzrdir.create_branch and
224
361
create_repository. If a shared repository is available that is used
266
465
:param force_new_repo: If True a new repository is always created.
267
466
:param force_new_tree: If True or False force creation of a tree or
268
467
prevent such creation respectively.
269
:param format: Override for the for the bzrdir format to create
468
:param format: Override for the bzrdir format to create.
469
:param possible_transports: An optional reusable transports list.
271
471
if force_new_tree:
272
472
# check for non local urls
273
t = get_transport(safe_unicode(base))
274
if not isinstance(t, LocalTransport):
473
t = get_transport(base, possible_transports)
474
if not isinstance(t, local.LocalTransport):
275
475
raise errors.NotLocalUrl(base)
277
bzrdir = BzrDir.create(base)
279
bzrdir = format.initialize(base)
476
bzrdir = BzrDir.create(base, format, possible_transports)
280
477
repo = bzrdir._find_or_create_repository(force_new_repo)
281
478
result = bzrdir.create_branch()
282
if force_new_tree or (repo.make_working_trees() and
479
if force_new_tree or (repo.make_working_trees() and
283
480
force_new_tree is None):
285
482
bzrdir.create_workingtree()
286
483
except errors.NotLocalUrl:
291
def create_repository(base, shared=False):
292
"""Create a new BzrDir and Repository at the url 'base'.
294
This will use the current default BzrDirFormat, and use whatever
295
repository format that that uses for bzrdirformat.create_repository.
297
;param shared: Create a shared repository rather than a standalone
299
The Repository object is returned.
301
This must be overridden as an instance method in child classes, where
302
it should take no parameters and construct whatever repository format
303
that child class desires.
305
bzrdir = BzrDir.create(base)
306
return bzrdir.create_repository()
309
def create_standalone_workingtree(base):
488
def create_standalone_workingtree(base, format=None):
310
489
"""Create a new BzrDir, WorkingTree, Branch and Repository at 'base'.
312
491
'base' must be a local path or a file:// url.
314
This will use the current default BzrDirFormat, and use whatever
493
This will use the current default BzrDirFormat unless one is
494
specified, and use whatever
315
495
repository format that that uses for bzrdirformat.create_workingtree,
316
496
create_branch and create_repository.
318
The WorkingTree object is returned.
498
:param format: Override for the bzrdir format to create.
499
:return: The WorkingTree object.
320
t = get_transport(safe_unicode(base))
321
if not isinstance(t, LocalTransport):
501
t = get_transport(base)
502
if not isinstance(t, local.LocalTransport):
322
503
raise errors.NotLocalUrl(base)
323
bzrdir = BzrDir.create_branch_and_repo(safe_unicode(base),
324
force_new_repo=True).bzrdir
504
bzrdir = BzrDir.create_branch_and_repo(base,
506
format=format).bzrdir
325
507
return bzrdir.create_workingtree()
327
def create_workingtree(self, revision_id=None):
509
def create_workingtree(self, revision_id=None, from_branch=None,
510
accelerator_tree=None, hardlink=False):
328
511
"""Create a working tree at this BzrDir.
330
revision_id: create it as of this revision id.
513
:param revision_id: create it as of this revision id.
514
:param from_branch: override bzrdir branch (for lightweight checkouts)
515
:param accelerator_tree: A tree which can be used for retrieving file
516
contents more quickly than the revision tree, i.e. a workingtree.
517
The revision tree will be used for cases where accelerator_tree's
518
content is different.
332
520
raise NotImplementedError(self.create_workingtree)
522
def backup_bzrdir(self):
523
"""Backup this bzr control directory.
525
:return: Tuple with old path name and new path name
527
self.root_transport.copy_tree('.bzr', 'backup.bzr')
528
return (self.root_transport.abspath('.bzr'),
529
self.root_transport.abspath('backup.bzr'))
531
def retire_bzrdir(self, limit=10000):
532
"""Permanently disable the bzrdir.
534
This is done by renaming it to give the user some ability to recover
535
if there was a problem.
537
This will have horrible consequences if anyone has anything locked or
539
:param limit: number of times to retry
544
to_path = '.bzr.retired.%d' % i
545
self.root_transport.rename('.bzr', to_path)
546
note("renamed %s to %s"
547
% (self.root_transport.abspath('.bzr'), to_path))
549
except (errors.TransportError, IOError, errors.PathError):
556
def destroy_workingtree(self):
557
"""Destroy the working tree at this BzrDir.
559
Formats that do not support this may raise UnsupportedOperation.
561
raise NotImplementedError(self.destroy_workingtree)
563
def destroy_workingtree_metadata(self):
564
"""Destroy the control files for the working tree at this BzrDir.
566
The contents of working tree files are not affected.
567
Formats that do not support this may raise UnsupportedOperation.
569
raise NotImplementedError(self.destroy_workingtree_metadata)
571
def _find_containing(self, evaluate):
572
"""Find something in a containing control directory.
574
This method will scan containing control dirs, until it finds what
575
it is looking for, decides that it will never find it, or runs out
576
of containing control directories to check.
578
It is used to implement find_repository and
579
determine_repository_policy.
581
:param evaluate: A function returning (value, stop). If stop is True,
582
the value will be returned.
586
result, stop = evaluate(found_bzrdir)
589
next_transport = found_bzrdir.root_transport.clone('..')
590
if (found_bzrdir.root_transport.base == next_transport.base):
591
# top of the file system
593
# find the next containing bzrdir
595
found_bzrdir = BzrDir.open_containing_from_transport(
597
except errors.NotBranchError:
334
600
def find_repository(self):
335
"""Find the repository that should be used for a_bzrdir.
601
"""Find the repository that should be used.
337
603
This does not require a branch as we use it to find the repo for
338
604
new branches as well as to hook existing branches up to their
342
return self.open_repository()
343
except errors.NoRepositoryPresent:
345
next_transport = self.root_transport.clone('..')
347
# find the next containing bzrdir
349
found_bzrdir = BzrDir.open_containing_from_transport(
351
except errors.NotBranchError:
353
raise errors.NoRepositoryPresent(self)
607
def usable_repository(found_bzrdir):
354
608
# does it have a repository ?
356
610
repository = found_bzrdir.open_repository()
357
611
except errors.NoRepositoryPresent:
358
next_transport = found_bzrdir.root_transport.clone('..')
359
if (found_bzrdir.root_transport.base == next_transport.base):
360
# top of the file system
364
if ((found_bzrdir.root_transport.base ==
365
self.root_transport.base) or repository.is_shared()):
613
if found_bzrdir.root_transport.base == self.root_transport.base:
614
return repository, True
615
elif repository.is_shared():
616
return repository, True
368
raise errors.NoRepositoryPresent(self)
369
raise errors.NoRepositoryPresent(self)
620
found_repo = self._find_containing(usable_repository)
621
if found_repo is None:
622
raise errors.NoRepositoryPresent(self)
625
def get_branch_reference(self):
626
"""Return the referenced URL for the branch in this bzrdir.
628
:raises NotBranchError: If there is no Branch.
629
:return: The URL the branch in this bzrdir references if it is a
630
reference branch, or None for regular branches.
371
634
def get_branch_transport(self, branch_format):
372
635
"""Get the transport for use by branch format in this BzrDir.
505
849
url = a_transport.base
508
format = BzrDirFormat.find_format(a_transport)
509
BzrDir._check_supported(format, False)
510
return format.open(a_transport), urlutils.unescape(a_transport.relpath(url))
852
result = BzrDir.open_from_transport(a_transport)
853
return result, urlutils.unescape(a_transport.relpath(url))
511
854
except errors.NotBranchError, e:
512
## mutter('not a branch in: %r %s', a_transport.base, e)
514
new_t = a_transport.clone('..')
857
new_t = a_transport.clone('..')
858
except errors.InvalidURLJoin:
859
# reached the root, whatever that may be
860
raise errors.NotBranchError(path=url)
515
861
if new_t.base == a_transport.base:
516
862
# reached the root, whatever that may be
517
863
raise errors.NotBranchError(path=url)
518
864
a_transport = new_t
866
def _get_tree_branch(self):
867
"""Return the branch and tree, if any, for this bzrdir.
869
Return None for tree if not present or inaccessible.
870
Raise NotBranchError if no branch is present.
871
:return: (tree, branch)
874
tree = self.open_workingtree()
875
except (errors.NoWorkingTree, errors.NotLocalUrl):
877
branch = self.open_branch()
883
def open_tree_or_branch(klass, location):
884
"""Return the branch and working tree at a location.
886
If there is no tree at the location, tree will be None.
887
If there is no branch at the location, an exception will be
889
:return: (tree, branch)
891
bzrdir = klass.open(location)
892
return bzrdir._get_tree_branch()
895
def open_containing_tree_or_branch(klass, location):
896
"""Return the branch and working tree contained by a location.
898
Returns (tree, branch, relpath).
899
If there is no tree at containing the location, tree will be None.
900
If there is no branch containing the location, an exception will be
902
relpath is the portion of the path that is contained by the branch.
904
bzrdir, relpath = klass.open_containing(location)
905
tree, branch = bzrdir._get_tree_branch()
906
return tree, branch, relpath
909
def open_containing_tree_branch_or_repository(klass, location):
910
"""Return the working tree, branch and repo contained by a location.
912
Returns (tree, branch, repository, relpath).
913
If there is no tree containing the location, tree will be None.
914
If there is no branch containing the location, branch will be None.
915
If there is no repository containing the location, repository will be
917
relpath is the portion of the path that is contained by the innermost
920
If no tree, branch or repository is found, a NotBranchError is raised.
922
bzrdir, relpath = klass.open_containing(location)
924
tree, branch = bzrdir._get_tree_branch()
925
except errors.NotBranchError:
927
repo = bzrdir.find_repository()
928
return None, None, repo, relpath
929
except (errors.NoRepositoryPresent):
930
raise errors.NotBranchError(location)
931
return tree, branch, branch.repository, relpath
520
933
def open_repository(self, _unsupported=False):
521
934
"""Open the repository object at this BzrDir if one is present.
523
This will not follow the Branch object pointer - its strictly a direct
936
This will not follow the Branch object pointer - it's strictly a direct
524
937
open facility. Most client code should use open_branch().repository to
525
938
get at a repository.
527
_unsupported is a private parameter, not part of the api.
940
:param _unsupported: a private parameter, not part of the api.
528
941
TODO: static convenience version of this?
530
943
raise NotImplementedError(self.open_repository)
532
def open_workingtree(self, _unsupported=False):
945
def open_workingtree(self, _unsupported=False,
946
recommend_upgrade=True, from_branch=None):
533
947
"""Open the workingtree object at this BzrDir if one is present.
535
TODO: static convenience version of this?
949
:param recommend_upgrade: Optional keyword parameter, when True (the
950
default), emit through the ui module a recommendation that the user
951
upgrade the working tree when the workingtree being opened is old
952
(but still fully supported).
953
:param from_branch: override bzrdir branch (for lightweight checkouts)
537
955
raise NotImplementedError(self.open_workingtree)
579
1062
if revision_id is not None, then the clone operation may tune
580
1063
itself to download less data.
1064
:param accelerator_tree: A tree which can be used for retrieving file
1065
contents more quickly than the revision tree, i.e. a workingtree.
1066
The revision tree will be used for cases where accelerator_tree's
1067
content is different.
1068
:param hardlink: If true, hard-link files from accelerator_tree,
1070
:param stacked: If true, create a stacked branch referring to the
1071
location of this control directory.
583
result = self._format.initialize(url)
584
basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
586
source_branch = self.open_branch()
1073
target_transport = get_transport(url, possible_transports)
1074
target_transport.ensure_base()
1075
cloning_format = self.cloning_metadir(stacked)
1076
# Create/update the result branch
1077
result = cloning_format.initialize_on_transport(target_transport)
1078
# if a stacked branch wasn't requested, we don't create one
1079
# even if the origin was stacked
1080
stacked_branch_url = None
1081
if source_branch is not None:
1083
stacked_branch_url = self.root_transport.base
587
1084
source_repository = source_branch.repository
588
except errors.NotBranchError:
591
source_repository = self.open_repository()
592
except errors.NoRepositoryPresent:
593
# copy the entire basis one if there is one
594
# but there is no repository.
595
source_repository = basis_repo
600
result_repo = result.find_repository()
601
except errors.NoRepositoryPresent:
603
if source_repository is None and result_repo is not None:
605
elif source_repository is None and result_repo is None:
606
# no repo available, make a new one
607
result.create_repository()
608
elif source_repository is not None and result_repo is None:
609
# have source, and want to make a new target repo
610
# we don't clone the repo because that preserves attributes
611
# like is_shared(), and we have not yet implemented a
612
# repository sprout().
613
result_repo = result.create_repository()
614
if result_repo is not None:
615
# fetch needed content into target.
617
# XXX FIXME RBC 20060214 need tests for this when the basis
619
result_repo.fetch(basis_repo, revision_id=revision_id)
1087
source_branch = self.open_branch()
1088
source_repository = source_branch.repository
1090
stacked_branch_url = self.root_transport.base
1091
except errors.NotBranchError:
1092
source_branch = None
1094
source_repository = self.open_repository()
1095
except errors.NoRepositoryPresent:
1096
source_repository = None
1097
repository_policy = result.determine_repository_policy(
1098
force_new_repo, stacked_branch_url, require_stacking=stacked)
1099
result_repo = repository_policy.acquire_repository()
1100
if source_repository is not None:
1101
# Fetch while stacked to prevent unstacked fetch from
620
1103
result_repo.fetch(source_repository, revision_id=revision_id)
1105
if source_branch is None:
1106
# this is for sprouting a bzrdir without a branch; is that
1108
# Not especially, but it's part of the contract.
1109
result_branch = result.create_branch()
1111
# Force NULL revision to avoid using repository before stacking
1113
result_branch = source_branch.sprout(
1114
result, revision_id=_mod_revision.NULL_REVISION)
1115
parent_location = result_branch.get_parent()
1116
mutter("created new branch %r" % (result_branch,))
1117
repository_policy.configure_branch(result_branch)
621
1118
if source_branch is not None:
622
source_branch.sprout(result, revision_id=revision_id)
1119
source_branch.copy_content_into(result_branch, revision_id)
1120
# Override copy_content_into
1121
result_branch.set_parent(parent_location)
1123
# Create/update the result working tree
1124
if isinstance(target_transport, local.LocalTransport) and (
1125
result_repo is None or result_repo.make_working_trees()):
1126
wt = result.create_workingtree(accelerator_tree=accelerator_tree,
1130
if wt.path2id('') is None:
1132
wt.set_root_id(self.open_workingtree.get_root_id())
1133
except errors.NoWorkingTree:
624
result.create_branch()
625
# TODO: jam 20060426 we probably need a test in here in the
626
# case that the newly sprouted branch is a remote one
627
if result_repo is None or result_repo.make_working_trees():
628
result.create_workingtree()
1139
if recurse == 'down':
1141
basis = wt.basis_tree()
1143
subtrees = basis.iter_references()
1144
elif result_branch is not None:
1145
basis = result_branch.basis_tree()
1147
subtrees = basis.iter_references()
1148
elif source_branch is not None:
1149
basis = source_branch.basis_tree()
1151
subtrees = basis.iter_references()
1156
for path, file_id in subtrees:
1157
target = urlutils.join(url, urlutils.escape(path))
1158
sublocation = source_branch.reference_parent(file_id, path)
1159
sublocation.bzrdir.sprout(target,
1160
basis.get_reference_revision(file_id, path),
1161
force_new_repo=force_new_repo, recurse=recurse,
1164
if basis is not None:
1878
2560
self.pb.note('starting repository conversion')
1879
2561
converter = CopyConverter(self.target_format.repository_format)
1880
2562
converter.convert(repo, pb)
2564
branch = self.bzrdir.open_branch()
2565
except errors.NotBranchError:
2568
# TODO: conversions of Branch and Tree should be done by
2569
# InterXFormat lookups/some sort of registry.
2570
# Avoid circular imports
2571
from bzrlib import branch as _mod_branch
2572
old = branch._format.__class__
2573
new = self.target_format.get_branch_format().__class__
2575
if (old == _mod_branch.BzrBranchFormat5 and
2576
new in (_mod_branch.BzrBranchFormat6,
2577
_mod_branch.BzrBranchFormat7)):
2578
branch_converter = _mod_branch.Converter5to6()
2579
elif (old == _mod_branch.BzrBranchFormat6 and
2580
new == _mod_branch.BzrBranchFormat7):
2581
branch_converter = _mod_branch.Converter6to7()
2583
raise errors.BadConversionTarget("No converter", new)
2584
branch_converter.convert(branch)
2585
branch = self.bzrdir.open_branch()
2586
old = branch._format.__class__
2588
tree = self.bzrdir.open_workingtree(recommend_upgrade=False)
2589
except (errors.NoWorkingTree, errors.NotLocalUrl):
2592
# TODO: conversions of Branch and Tree should be done by
2593
# InterXFormat lookups
2594
if (isinstance(tree, workingtree.WorkingTree3) and
2595
not isinstance(tree, workingtree_4.DirStateWorkingTree) and
2596
isinstance(self.target_format.workingtree_format,
2597
workingtree_4.DirStateWorkingTreeFormat)):
2598
workingtree_4.Converter3to4().convert(tree)
2599
if (isinstance(tree, workingtree_4.DirStateWorkingTree) and
2600
not isinstance(tree, workingtree_4.WorkingTree5) and
2601
isinstance(self.target_format.workingtree_format,
2602
workingtree_4.WorkingTreeFormat5)):
2603
workingtree_4.Converter4to5().convert(tree)
1881
2604
return to_convert
2607
# This is not in remote.py because it's small, and needs to be registered.
2608
# Putting it in remote.py creates a circular import problem.
2609
# we can make it a lazy object if the control formats is turned into something
2611
class RemoteBzrDirFormat(BzrDirMetaFormat1):
2612
"""Format representing bzrdirs accessed via a smart server"""
2614
def get_format_description(self):
2615
return 'bzr remote bzrdir'
2618
def probe_transport(klass, transport):
2619
"""Return a RemoteBzrDirFormat object if it looks possible."""
2621
medium = transport.get_smart_medium()
2622
except (NotImplementedError, AttributeError,
2623
errors.TransportNotPossible, errors.NoSmartMedium,
2624
errors.SmartProtocolError):
2625
# no smart server, so not a branch for this format type.
2626
raise errors.NotBranchError(path=transport.base)
2628
# Decline to open it if the server doesn't support our required
2629
# version (3) so that the VFS-based transport will do it.
2630
if medium.should_probe():
2632
server_version = medium.protocol_version()
2633
except errors.SmartProtocolError:
2634
# Apparently there's no usable smart server there, even though
2635
# the medium supports the smart protocol.
2636
raise errors.NotBranchError(path=transport.base)
2637
if server_version != '2':
2638
raise errors.NotBranchError(path=transport.base)
2641
def initialize_on_transport(self, transport):
2643
# hand off the request to the smart server
2644
client_medium = transport.get_smart_medium()
2645
except errors.NoSmartMedium:
2646
# TODO: lookup the local format from a server hint.
2647
local_dir_format = BzrDirMetaFormat1()
2648
return local_dir_format.initialize_on_transport(transport)
2649
client = _SmartClient(client_medium)
2650
path = client.remote_path_from_transport(transport)
2651
response = client.call('BzrDirFormat.initialize', path)
2652
if response[0] != 'ok':
2653
raise errors.SmartProtocolError('unexpected response code %s' % (response,))
2654
return remote.RemoteBzrDir(transport)
2656
def _open(self, transport):
2657
return remote.RemoteBzrDir(transport)
2659
def __eq__(self, other):
2660
if not isinstance(other, RemoteBzrDirFormat):
2662
return self.get_format_description() == other.get_format_description()
2665
def repository_format(self):
2666
# Using a property to avoid early loading of remote
2667
return remote.RemoteRepositoryFormat()
2670
BzrDirFormat.register_control_server_format(RemoteBzrDirFormat)
2673
class BzrDirFormatInfo(object):
2675
def __init__(self, native, deprecated, hidden, experimental):
2676
self.deprecated = deprecated
2677
self.native = native
2678
self.hidden = hidden
2679
self.experimental = experimental
2682
class BzrDirFormatRegistry(registry.Registry):
2683
"""Registry of user-selectable BzrDir subformats.
2685
Differs from BzrDirFormat._control_formats in that it provides sub-formats,
2686
e.g. BzrDirMeta1 with weave repository. Also, it's more user-oriented.
2690
"""Create a BzrDirFormatRegistry."""
2691
self._aliases = set()
2692
self._registration_order = list()
2693
super(BzrDirFormatRegistry, self).__init__()
2696
"""Return a set of the format names which are aliases."""
2697
return frozenset(self._aliases)
2699
def register_metadir(self, key,
2700
repository_format, help, native=True, deprecated=False,
2706
"""Register a metadir subformat.
2708
These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
2709
by the Repository format.
2711
:param repository_format: The fully-qualified repository format class
2713
:param branch_format: Fully-qualified branch format class name as
2715
:param tree_format: Fully-qualified tree format class name as
2718
# This should be expanded to support setting WorkingTree and Branch
2719
# formats, once BzrDirMetaFormat1 supports that.
2720
def _load(full_name):
2721
mod_name, factory_name = full_name.rsplit('.', 1)
2723
mod = __import__(mod_name, globals(), locals(),
2725
except ImportError, e:
2726
raise ImportError('failed to load %s: %s' % (full_name, e))
2728
factory = getattr(mod, factory_name)
2729
except AttributeError:
2730
raise AttributeError('no factory %s in module %r'
2735
bd = BzrDirMetaFormat1()
2736
if branch_format is not None:
2737
bd.set_branch_format(_load(branch_format))
2738
if tree_format is not None:
2739
bd.workingtree_format = _load(tree_format)
2740
if repository_format is not None:
2741
bd.repository_format = _load(repository_format)
2743
self.register(key, helper, help, native, deprecated, hidden,
2744
experimental, alias)
2746
def register(self, key, factory, help, native=True, deprecated=False,
2747
hidden=False, experimental=False, alias=False):
2748
"""Register a BzrDirFormat factory.
2750
The factory must be a callable that takes one parameter: the key.
2751
It must produce an instance of the BzrDirFormat when called.
2753
This function mainly exists to prevent the info object from being
2756
registry.Registry.register(self, key, factory, help,
2757
BzrDirFormatInfo(native, deprecated, hidden, experimental))
2759
self._aliases.add(key)
2760
self._registration_order.append(key)
2762
def register_lazy(self, key, module_name, member_name, help, native=True,
2763
deprecated=False, hidden=False, experimental=False, alias=False):
2764
registry.Registry.register_lazy(self, key, module_name, member_name,
2765
help, BzrDirFormatInfo(native, deprecated, hidden, experimental))
2767
self._aliases.add(key)
2768
self._registration_order.append(key)
2770
def set_default(self, key):
2771
"""Set the 'default' key to be a clone of the supplied key.
2773
This method must be called once and only once.
2775
registry.Registry.register(self, 'default', self.get(key),
2776
self.get_help(key), info=self.get_info(key))
2777
self._aliases.add('default')
2779
def set_default_repository(self, key):
2780
"""Set the FormatRegistry default and Repository default.
2782
This is a transitional method while Repository.set_default_format
2785
if 'default' in self:
2786
self.remove('default')
2787
self.set_default(key)
2788
format = self.get('default')()
2790
def make_bzrdir(self, key):
2791
return self.get(key)()
2793
def help_topic(self, topic):
2795
default_realkey = None
2796
default_help = self.get_help('default')
2798
for key in self._registration_order:
2799
if key == 'default':
2801
help = self.get_help(key)
2802
if help == default_help:
2803
default_realkey = key
2805
help_pairs.append((key, help))
2807
def wrapped(key, help, info):
2809
help = '(native) ' + help
2810
return ':%s:\n%s\n\n' % (key,
2811
textwrap.fill(help, initial_indent=' ',
2812
subsequent_indent=' '))
2813
if default_realkey is not None:
2814
output += wrapped(default_realkey, '(default) %s' % default_help,
2815
self.get_info('default'))
2816
deprecated_pairs = []
2817
experimental_pairs = []
2818
for key, help in help_pairs:
2819
info = self.get_info(key)
2822
elif info.deprecated:
2823
deprecated_pairs.append((key, help))
2824
elif info.experimental:
2825
experimental_pairs.append((key, help))
2827
output += wrapped(key, help, info)
2828
output += "\nSee ``bzr help formats`` for more about storage formats."
2830
if len(experimental_pairs) > 0:
2831
other_output += "Experimental formats are shown below.\n\n"
2832
for key, help in experimental_pairs:
2833
info = self.get_info(key)
2834
other_output += wrapped(key, help, info)
2837
"No experimental formats are available.\n\n"
2838
if len(deprecated_pairs) > 0:
2839
other_output += "\nDeprecated formats are shown below.\n\n"
2840
for key, help in deprecated_pairs:
2841
info = self.get_info(key)
2842
other_output += wrapped(key, help, info)
2845
"\nNo deprecated formats are available.\n\n"
2847
"\nSee ``bzr help formats`` for more about storage formats."
2849
if topic == 'other-formats':
2855
class RepositoryAcquisitionPolicy(object):
2856
"""Abstract base class for repository acquisition policies.
2858
A repository acquisition policy decides how a BzrDir acquires a repository
2859
for a branch that is being created. The most basic policy decision is
2860
whether to create a new repository or use an existing one.
2862
def __init__(self, stack_on, stack_on_pwd, require_stacking):
2865
:param stack_on: A location to stack on
2866
:param stack_on_pwd: If stack_on is relative, the location it is
2868
:param require_stacking: If True, it is a failure to not stack.
2870
self._stack_on = stack_on
2871
self._stack_on_pwd = stack_on_pwd
2872
self._require_stacking = require_stacking
2874
def configure_branch(self, branch):
2875
"""Apply any configuration data from this policy to the branch.
2877
Default implementation sets repository stacking.
2879
if self._stack_on is None:
2881
if self._stack_on_pwd is None:
2882
stack_on = self._stack_on
2885
stack_on = urlutils.rebase_url(self._stack_on,
2887
branch.bzrdir.root_transport.base)
2888
except errors.InvalidRebaseURLs:
2889
stack_on = self._get_full_stack_on()
2891
branch.set_stacked_on_url(stack_on)
2892
except errors.UnstackableBranchFormat:
2893
if self._require_stacking:
2896
def _get_full_stack_on(self):
2897
"""Get a fully-qualified URL for the stack_on location."""
2898
if self._stack_on is None:
2900
if self._stack_on_pwd is None:
2901
return self._stack_on
2903
return urlutils.join(self._stack_on_pwd, self._stack_on)
2905
def _add_fallback(self, repository, possible_transports=None):
2906
"""Add a fallback to the supplied repository, if stacking is set."""
2907
stack_on = self._get_full_stack_on()
2908
if stack_on is None:
2910
stacked_dir = BzrDir.open(stack_on,
2911
possible_transports=possible_transports)
2913
stacked_repo = stacked_dir.open_branch().repository
2914
except errors.NotBranchError:
2915
stacked_repo = stacked_dir.open_repository()
2917
repository.add_fallback_repository(stacked_repo)
2918
except errors.UnstackableRepositoryFormat:
2919
if self._require_stacking:
2922
self._require_stacking = True
2924
def acquire_repository(self, make_working_trees=None, shared=False):
2925
"""Acquire a repository for this bzrdir.
2927
Implementations may create a new repository or use a pre-exising
2929
:param make_working_trees: If creating a repository, set
2930
make_working_trees to this value (if non-None)
2931
:param shared: If creating a repository, make it shared if True
2932
:return: A repository
2934
raise NotImplemented(RepositoryAcquisitionPolicy.acquire_repository)
2937
class CreateRepository(RepositoryAcquisitionPolicy):
2938
"""A policy of creating a new repository"""
2940
def __init__(self, bzrdir, stack_on=None, stack_on_pwd=None,
2941
require_stacking=False):
2944
:param bzrdir: The bzrdir to create the repository on.
2945
:param stack_on: A location to stack on
2946
:param stack_on_pwd: If stack_on is relative, the location it is
2949
RepositoryAcquisitionPolicy.__init__(self, stack_on, stack_on_pwd,
2951
self._bzrdir = bzrdir
2953
def acquire_repository(self, make_working_trees=None, shared=False):
2954
"""Implementation of RepositoryAcquisitionPolicy.acquire_repository
2956
Creates the desired repository in the bzrdir we already have.
2958
repository = self._bzrdir.create_repository(shared=shared)
2959
self._add_fallback(repository,
2960
possible_transports=[self._bzrdir.transport])
2961
if make_working_trees is not None:
2962
repository.set_make_working_trees(make_working_trees)
2966
class UseExistingRepository(RepositoryAcquisitionPolicy):
2967
"""A policy of reusing an existing repository"""
2969
def __init__(self, repository, stack_on=None, stack_on_pwd=None,
2970
require_stacking=False):
2973
:param repository: The repository to use.
2974
:param stack_on: A location to stack on
2975
:param stack_on_pwd: If stack_on is relative, the location it is
2978
RepositoryAcquisitionPolicy.__init__(self, stack_on, stack_on_pwd,
2980
self._repository = repository
2982
def acquire_repository(self, make_working_trees=None, shared=False):
2983
"""Implementation of RepositoryAcquisitionPolicy.acquire_repository
2985
Returns an existing repository to use
2987
self._add_fallback(self._repository,
2988
possible_transports=[self._repository.bzrdir.transport])
2989
return self._repository
2992
# Please register new formats after old formats so that formats
2993
# appear in chronological order and format descriptions can build
2995
format_registry = BzrDirFormatRegistry()
2996
format_registry.register('weave', BzrDirFormat6,
2997
'Pre-0.8 format. Slower than knit and does not'
2998
' support checkouts or shared repositories.',
3000
format_registry.register_metadir('metaweave',
3001
'bzrlib.repofmt.weaverepo.RepositoryFormat7',
3002
'Transitional format in 0.8. Slower than knit.',
3003
branch_format='bzrlib.branch.BzrBranchFormat5',
3004
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3006
format_registry.register_metadir('knit',
3007
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3008
'Format using knits. Recommended for interoperation with bzr <= 0.14.',
3009
branch_format='bzrlib.branch.BzrBranchFormat5',
3010
tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3012
format_registry.register_metadir('dirstate',
3013
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3014
help='New in 0.15: Fast local operations. Compatible with bzr 0.8 and '
3015
'above when accessed over the network.',
3016
branch_format='bzrlib.branch.BzrBranchFormat5',
3017
# this uses bzrlib.workingtree.WorkingTreeFormat4 because importing
3018
# directly from workingtree_4 triggers a circular import.
3019
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3021
format_registry.register_metadir('dirstate-tags',
3022
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3023
help='New in 0.15: Fast local operations and improved scaling for '
3024
'network operations. Additionally adds support for tags.'
3025
' Incompatible with bzr < 0.15.',
3026
branch_format='bzrlib.branch.BzrBranchFormat6',
3027
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3029
format_registry.register_metadir('rich-root',
3030
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit4',
3031
help='New in 1.0. Better handling of tree roots. Incompatible with'
3033
branch_format='bzrlib.branch.BzrBranchFormat6',
3034
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3036
format_registry.register_metadir('dirstate-with-subtree',
3037
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
3038
help='New in 0.15: Fast local operations and improved scaling for '
3039
'network operations. Additionally adds support for versioning nested '
3040
'bzr branches. Incompatible with bzr < 0.15.',
3041
branch_format='bzrlib.branch.BzrBranchFormat6',
3042
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3046
format_registry.register_metadir('pack-0.92',
3047
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack1',
3048
help='New in 0.92: Pack-based format with data compatible with '
3049
'dirstate-tags format repositories. Interoperates with '
3050
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3051
'Previously called knitpack-experimental. '
3052
'For more information, see '
3053
'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
3054
branch_format='bzrlib.branch.BzrBranchFormat6',
3055
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3057
format_registry.register_metadir('pack-0.92-subtree',
3058
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack3',
3059
help='New in 0.92: Pack-based format with data compatible with '
3060
'dirstate-with-subtree format repositories. Interoperates with '
3061
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3062
'Previously called knitpack-experimental. '
3063
'For more information, see '
3064
'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
3065
branch_format='bzrlib.branch.BzrBranchFormat6',
3066
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3070
format_registry.register_metadir('rich-root-pack',
3071
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack4',
3072
help='New in 1.0: A variant of pack-0.92 that supports rich-root data '
3073
'(needed for bzr-svn).',
3074
branch_format='bzrlib.branch.BzrBranchFormat6',
3075
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3077
format_registry.register_metadir('1.6',
3078
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5',
3079
help='A format that allows a branch to indicate that there is another '
3080
'(stacked) repository that should be used to access data that is '
3081
'not present locally.',
3082
branch_format='bzrlib.branch.BzrBranchFormat7',
3083
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3085
format_registry.register_metadir('1.6.1-rich-root',
3086
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5RichRoot',
3087
help='A variant of 1.6 that supports rich-root data '
3088
'(needed for bzr-svn).',
3089
branch_format='bzrlib.branch.BzrBranchFormat7',
3090
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3092
format_registry.register_metadir('1.9',
3093
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3094
help='A repository format using B+tree indexes. These indexes '
3095
'are smaller in size, have smarter caching and provide faster '
3096
'performance for most operations.',
3097
branch_format='bzrlib.branch.BzrBranchFormat7',
3098
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3100
format_registry.register_metadir('1.9-rich-root',
3101
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3102
help='A variant of 1.9 that supports rich-root data '
3103
'(needed for bzr-svn).',
3104
branch_format='bzrlib.branch.BzrBranchFormat7',
3105
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3107
format_registry.register_metadir('1.12-preview',
3108
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3109
help='A working-tree format that supports views and content filtering.',
3110
branch_format='bzrlib.branch.BzrBranchFormat7',
3111
tree_format='bzrlib.workingtree_4.WorkingTreeFormat5',
3114
format_registry.register_metadir('1.12-preview-rich-root',
3115
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3116
help='A variant of 1.12-preview that supports rich-root data '
3117
'(needed for bzr-svn).',
3118
branch_format='bzrlib.branch.BzrBranchFormat7',
3119
tree_format='bzrlib.workingtree_4.WorkingTreeFormat5',
3122
# The following two formats should always just be aliases.
3123
format_registry.register_metadir('development',
3124
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2',
3125
help='Current development format. Can convert data to and from pack-0.92 '
3126
'(and anything compatible with pack-0.92) format repositories. '
3127
'Repositories and branches in this format can only be read by bzr.dev. '
3129
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3131
branch_format='bzrlib.branch.BzrBranchFormat7',
3132
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3136
format_registry.register_metadir('development-subtree',
3137
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
3138
help='Current development format, subtree variant. Can convert data to and '
3139
'from pack-0.92-subtree (and anything compatible with '
3140
'pack-0.92-subtree) format repositories. Repositories and branches in '
3141
'this format can only be read by bzr.dev. Please read '
3142
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3144
branch_format='bzrlib.branch.BzrBranchFormat7',
3145
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3149
# And the development formats above will have aliased one of the following:
3150
format_registry.register_metadir('development2',
3151
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2',
3152
help='1.6.1 with B+Tree based index. '
3154
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3156
branch_format='bzrlib.branch.BzrBranchFormat7',
3157
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3161
format_registry.register_metadir('development2-subtree',
3162
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
3163
help='1.6.1-subtree with B+Tree based index. '
3165
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3167
branch_format='bzrlib.branch.BzrBranchFormat7',
3168
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3172
# The current format that is made on 'bzr init'.
3173
format_registry.set_default('pack-0.92')
added
removed
bzrlib/bzrdir.py
