157
152
format.get_format_description(),
160
def clone(self, url, revision_id=None, force_new_repo=False,
161
preserve_stacking=False):
155
def clone(self, url, revision_id=None, force_new_repo=False):
162
156
"""Clone this bzrdir and its contents to url verbatim.
164
:param url: The url create the clone at. If url's last component does
165
not exist, it will be created.
166
:param revision_id: The tip revision-id to use for any branch or
167
working tree. If not None, then the clone operation may tune
158
If url's last component does not exist, it will be created.
160
if revision_id is not None, then the clone operation may tune
168
161
itself to download less data.
169
:param force_new_repo: Do not use a shared repository for the target
162
:param force_new_repo: Do not use a shared repository for the target
170
163
even if one is available.
171
:param preserve_stacking: When cloning a stacked branch, stack the
172
new branch on top of the other branch's stacked-on branch.
174
165
return self.clone_on_transport(get_transport(url),
175
166
revision_id=revision_id,
176
force_new_repo=force_new_repo,
177
preserve_stacking=preserve_stacking)
167
force_new_repo=force_new_repo)
179
169
def clone_on_transport(self, transport, revision_id=None,
180
force_new_repo=False, preserve_stacking=False,
170
force_new_repo=False):
182
171
"""Clone this bzrdir and its contents to transport verbatim.
184
:param transport: The transport for the location to produce the clone
185
at. If the target directory does not exist, it will be created.
186
:param revision_id: The tip revision-id to use for any branch or
187
working tree. If not None, then the clone operation may tune
173
If the target directory does not exist, it will be created.
175
if revision_id is not None, then the clone operation may tune
188
176
itself to download less data.
189
:param force_new_repo: Do not use a shared repository for the target,
177
:param force_new_repo: Do not use a shared repository for the target
190
178
even if one is available.
191
:param preserve_stacking: When cloning a stacked branch, stack the
192
new branch on top of the other branch's stacked-on branch.
194
180
transport.ensure_base()
195
require_stacking = (stacked_on is not None)
196
metadir = self.cloning_metadir(require_stacking)
197
result = metadir.initialize_on_transport(transport)
198
repository_policy = None
181
result = self._format.initialize_on_transport(transport)
200
183
local_repo = self.find_repository()
201
184
except errors.NoRepositoryPresent:
202
185
local_repo = None
204
local_branch = self.open_branch()
205
except errors.NotBranchError:
208
# enable fallbacks when branch is not a branch reference
209
if local_branch.repository.has_same_location(local_repo):
210
local_repo = local_branch.repository
211
if preserve_stacking:
213
stacked_on = local_branch.get_stacked_on_url()
214
except (errors.UnstackableBranchFormat,
215
errors.UnstackableRepositoryFormat,
220
187
# may need to copy content in
221
repository_policy = result.determine_repository_policy(
222
force_new_repo, stacked_on, self.root_transport.base,
223
require_stacking=require_stacking)
224
make_working_trees = local_repo.make_working_trees()
225
result_repo = repository_policy.acquire_repository(
226
make_working_trees, local_repo.is_shared())
227
result_repo.fetch(local_repo, revision_id=revision_id)
189
result_repo = local_repo.clone(
191
revision_id=revision_id)
192
result_repo.set_make_working_trees(local_repo.make_working_trees())
195
result_repo = result.find_repository()
196
# fetch content this dir needs.
197
result_repo.fetch(local_repo, revision_id=revision_id)
198
except errors.NoRepositoryPresent:
199
# needed to make one anyway.
200
result_repo = local_repo.clone(
202
revision_id=revision_id)
203
result_repo.set_make_working_trees(local_repo.make_working_trees())
230
204
# 1 if there is a branch present
231
205
# make sure its content is available in the target repository
233
if local_branch is not None:
234
result_branch = local_branch.clone(result, revision_id=revision_id)
235
if repository_policy is not None:
236
repository_policy.configure_branch(result_branch)
237
if result_repo is None or result_repo.make_working_trees():
239
self.open_workingtree().clone(result)
240
except (errors.NoWorkingTree, errors.NotLocalUrl):
208
self.open_branch().clone(result, revision_id=revision_id)
209
except errors.NotBranchError:
212
self.open_workingtree().clone(result)
213
except (errors.NoWorkingTree, errors.NotLocalUrl):
244
217
# TODO: This should be given a Transport, and should chdir up; otherwise
265
238
format = BzrDirFormat.get_default_format()
266
239
return format.initialize_on_transport(t)
269
def find_bzrdirs(transport, evaluate=None, list_current=None):
270
"""Find bzrdirs recursively from current location.
272
This is intended primarily as a building block for more sophisticated
273
functionality, like finding trees under a directory, or finding
274
branches that use a given repository.
275
:param evaluate: An optional callable that yields recurse, value,
276
where recurse controls whether this bzrdir is recursed into
277
and value is the value to yield. By default, all bzrdirs
278
are recursed into, and the return value is the bzrdir.
279
:param list_current: if supplied, use this function to list the current
280
directory, instead of Transport.list_dir
281
:return: a generator of found bzrdirs, or whatever evaluate returns.
283
if list_current is None:
284
def list_current(transport):
285
return transport.list_dir('')
287
def evaluate(bzrdir):
290
pending = [transport]
291
while len(pending) > 0:
292
current_transport = pending.pop()
295
bzrdir = BzrDir.open_from_transport(current_transport)
296
except errors.NotBranchError:
299
recurse, value = evaluate(bzrdir)
302
subdirs = list_current(current_transport)
303
except errors.NoSuchFile:
306
for subdir in sorted(subdirs, reverse=True):
307
pending.append(current_transport.clone(subdir))
310
def find_branches(transport):
311
"""Find all branches under a transport.
313
This will find all branches below the transport, including branches
314
inside other branches. Where possible, it will use
315
Repository.find_branches.
317
To list all the branches that use a particular Repository, see
318
Repository.find_branches
320
def evaluate(bzrdir):
322
repository = bzrdir.open_repository()
323
except errors.NoRepositoryPresent:
326
return False, (None, repository)
328
branch = bzrdir.open_branch()
329
except errors.NotBranchError:
330
return True, (None, None)
332
return True, (branch, None)
334
for branch, repo in BzrDir.find_bzrdirs(transport, evaluate=evaluate):
336
branches.extend(repo.find_branches())
337
if branch is not None:
338
branches.append(branch)
341
def destroy_repository(self):
342
"""Destroy the repository in this BzrDir"""
343
raise NotImplementedError(self.destroy_repository)
345
241
def create_branch(self):
346
242
"""Create a branch in this BzrDir.
375
271
bzrdir._find_or_create_repository(force_new_repo)
376
272
return bzrdir.create_branch()
378
def determine_repository_policy(self, force_new_repo=False, stack_on=None,
379
stack_on_pwd=None, require_stacking=False):
380
"""Return an object representing a policy to use.
382
This controls whether a new repository is created, or a shared
383
repository used instead.
385
If stack_on is supplied, will not seek a containing shared repo.
387
:param force_new_repo: If True, require a new repository to be created.
388
:param stack_on: If supplied, the location to stack on. If not
389
supplied, a default_stack_on location may be used.
390
:param stack_on_pwd: If stack_on is relative, the location it is
393
def repository_policy(found_bzrdir):
396
config = found_bzrdir.get_config()
398
if config is not None:
399
stack_on = config.get_default_stack_on()
400
if stack_on is not None:
401
stack_on_pwd = found_bzrdir.root_transport.base
403
note('Using default stacking branch %s at %s', stack_on,
405
# does it have a repository ?
407
repository = found_bzrdir.open_repository()
408
except errors.NoRepositoryPresent:
411
if ((found_bzrdir.root_transport.base !=
412
self.root_transport.base) and not repository.is_shared()):
419
return UseExistingRepository(repository, stack_on,
420
stack_on_pwd, require_stacking=require_stacking), True
422
return CreateRepository(self, stack_on, stack_on_pwd,
423
require_stacking=require_stacking), True
425
if not force_new_repo:
427
policy = self._find_containing(repository_policy)
428
if policy is not None:
432
return UseExistingRepository(self.open_repository(),
433
stack_on, stack_on_pwd,
434
require_stacking=require_stacking)
435
except errors.NoRepositoryPresent:
437
return CreateRepository(self, stack_on, stack_on_pwd,
438
require_stacking=require_stacking)
440
274
def _find_or_create_repository(self, force_new_repo):
441
275
"""Create a new repository if needed, returning the repository."""
442
policy = self.determine_repository_policy(force_new_repo)
443
return policy.acquire_repository()
277
return self.create_repository()
279
return self.find_repository()
280
except errors.NoRepositoryPresent:
281
return self.create_repository()
446
284
def create_branch_convenience(base, force_new_repo=False,
447
285
force_new_tree=None, format=None,
329
@deprecated_function(zero_ninetyone)
330
def create_repository(base, shared=False, format=None):
331
"""Create a new BzrDir and Repository at the url 'base'.
333
If no format is supplied, this will default to the current default
334
BzrDirFormat by default, and use whatever repository format that that
335
uses for bzrdirformat.create_repository.
337
:param shared: Create a shared repository rather than a standalone
339
The Repository object is returned.
341
This must be overridden as an instance method in child classes, where
342
it should take no parameters and construct whatever repository format
343
that child class desires.
345
This method is deprecated, please call create_repository on a bzrdir
348
bzrdir = BzrDir.create(base, format)
349
return bzrdir.create_repository(shared)
491
352
def create_standalone_workingtree(base, format=None):
492
353
"""Create a new BzrDir, WorkingTree, Branch and Repository at 'base'.
563
418
raise NotImplementedError(self.destroy_workingtree_metadata)
565
def _find_containing(self, evaluate):
566
"""Find something in a containing control directory.
568
This method will scan containing control dirs, until it finds what
569
it is looking for, decides that it will never find it, or runs out
570
of containing control directories to check.
572
It is used to implement find_repository and
573
determine_repository_policy.
575
:param evaluate: A function returning (value, stop). If stop is True,
576
the value will be returned.
580
result, stop = evaluate(found_bzrdir)
583
next_transport = found_bzrdir.root_transport.clone('..')
584
if (found_bzrdir.root_transport.base == next_transport.base):
585
# top of the file system
587
# find the next containing bzrdir
589
found_bzrdir = BzrDir.open_containing_from_transport(
591
except errors.NotBranchError:
594
420
def find_repository(self):
595
421
"""Find the repository that should be used.
598
424
new branches as well as to hook existing branches up to their
601
def usable_repository(found_bzrdir):
428
return self.open_repository()
429
except errors.NoRepositoryPresent:
431
next_transport = self.root_transport.clone('..')
433
# find the next containing bzrdir
435
found_bzrdir = BzrDir.open_containing_from_transport(
437
except errors.NotBranchError:
439
raise errors.NoRepositoryPresent(self)
602
440
# does it have a repository ?
604
442
repository = found_bzrdir.open_repository()
605
443
except errors.NoRepositoryPresent:
607
if found_bzrdir.root_transport.base == self.root_transport.base:
608
return repository, True
609
elif repository.is_shared():
610
return repository, True
444
next_transport = found_bzrdir.root_transport.clone('..')
445
if (found_bzrdir.root_transport.base == next_transport.base):
446
# top of the file system
450
if ((found_bzrdir.root_transport.base ==
451
self.root_transport.base) or repository.is_shared()):
614
found_repo = self._find_containing(usable_repository)
615
if found_repo is None:
616
raise errors.NoRepositoryPresent(self)
454
raise errors.NoRepositoryPresent(self)
455
raise errors.NoRepositoryPresent(self)
619
457
def get_branch_reference(self):
620
458
"""Return the referenced URL for the branch in this bzrdir.
637
475
guaranteed to point to an existing directory ready for use.
639
477
raise NotImplementedError(self.get_branch_transport)
641
def _find_creation_modes(self):
642
"""Determine the appropriate modes for files and directories.
644
They're always set to be consistent with the base directory,
645
assuming that this transport allows setting modes.
647
# TODO: Do we need or want an option (maybe a config setting) to turn
648
# this off or override it for particular locations? -- mbp 20080512
649
if self._mode_check_done:
651
self._mode_check_done = True
653
st = self.transport.stat('.')
654
except errors.TransportNotPossible:
655
self._dir_mode = None
656
self._file_mode = None
658
# Check the directory mode, but also make sure the created
659
# directories and files are read-write for this user. This is
660
# mostly a workaround for filesystems which lie about being able to
661
# write to a directory (cygwin & win32)
662
if (st.st_mode & 07777 == 00000):
663
# FTP allows stat but does not return dir/file modes
664
self._dir_mode = None
665
self._file_mode = None
667
self._dir_mode = (st.st_mode & 07777) | 00700
668
# Remove the sticky and execute bits for files
669
self._file_mode = self._dir_mode & ~07111
671
def _get_file_mode(self):
672
"""Return Unix mode for newly created files, or None.
674
if not self._mode_check_done:
675
self._find_creation_modes()
676
return self._file_mode
678
def _get_dir_mode(self):
679
"""Return Unix mode for newly created directories, or None.
681
if not self._mode_check_done:
682
self._find_creation_modes()
683
return self._dir_mode
685
479
def get_repository_transport(self, repository_format):
686
480
"""Get the transport for use by repository format in this BzrDir.
866
654
raise errors.NotBranchError(path=url)
867
655
a_transport = new_t
869
def _get_tree_branch(self):
870
"""Return the branch and tree, if any, for this bzrdir.
872
Return None for tree if not present or inaccessible.
873
Raise NotBranchError if no branch is present.
874
:return: (tree, branch)
877
tree = self.open_workingtree()
878
except (errors.NoWorkingTree, errors.NotLocalUrl):
880
branch = self.open_branch()
886
def open_tree_or_branch(klass, location):
887
"""Return the branch and working tree at a location.
889
If there is no tree at the location, tree will be None.
890
If there is no branch at the location, an exception will be
892
:return: (tree, branch)
894
bzrdir = klass.open(location)
895
return bzrdir._get_tree_branch()
898
658
def open_containing_tree_or_branch(klass, location):
899
659
"""Return the branch and working tree contained by a location.
905
665
relpath is the portion of the path that is contained by the branch.
907
667
bzrdir, relpath = klass.open_containing(location)
908
tree, branch = bzrdir._get_tree_branch()
669
tree = bzrdir.open_workingtree()
670
except (errors.NoWorkingTree, errors.NotLocalUrl):
672
branch = bzrdir.open_branch()
909
675
return tree, branch, relpath
912
def open_containing_tree_branch_or_repository(klass, location):
913
"""Return the working tree, branch and repo contained by a location.
915
Returns (tree, branch, repository, relpath).
916
If there is no tree containing the location, tree will be None.
917
If there is no branch containing the location, branch will be None.
918
If there is no repository containing the location, repository will be
920
relpath is the portion of the path that is contained by the innermost
923
If no tree, branch or repository is found, a NotBranchError is raised.
925
bzrdir, relpath = klass.open_containing(location)
927
tree, branch = bzrdir._get_tree_branch()
928
except errors.NotBranchError:
930
repo = bzrdir.find_repository()
931
return None, None, repo, relpath
932
except (errors.NoRepositoryPresent):
933
raise errors.NotBranchError(location)
934
return tree, branch, branch.repository, relpath
936
677
def open_repository(self, _unsupported=False):
937
678
"""Open the repository object at this BzrDir if one is present.
1040
770
tree_format = repository._format._matchingbzrdir.workingtree_format
1041
771
format.workingtree_format = tree_format.__class__()
1042
if (require_stacking and not
1043
format.get_branch_format().supports_stacking()):
1044
# We need to make a stacked branch, but the default format for the
1045
# target doesn't support stacking. So force a branch that *can*
1047
from bzrlib.branch import BzrBranchFormat7
1048
format._branch_format = BzrBranchFormat7()
1049
mutter("using %r for stacking" % (format._branch_format,))
1050
from bzrlib.repofmt import pack_repo
1051
if format.repository_format.rich_root_data:
1052
bzrdir_format_name = '1.6.1-rich-root'
1053
repo_format = pack_repo.RepositoryFormatKnitPack5RichRoot()
1055
bzrdir_format_name = '1.6'
1056
repo_format = pack_repo.RepositoryFormatKnitPack5()
1057
note('Source format does not support stacking, using format:'
1059
bzrdir_format_name, repo_format.get_format_description())
1060
format.repository_format = repo_format
1063
774
def checkout_metadir(self):
1064
775
return self.cloning_metadir()
1066
777
def sprout(self, url, revision_id=None, force_new_repo=False,
1067
recurse='down', possible_transports=None,
1068
accelerator_tree=None, hardlink=False, stacked=False):
778
recurse='down', possible_transports=None):
1069
779
"""Create a copy of this bzrdir prepared for use as a new line of
1079
789
if revision_id is not None, then the clone operation may tune
1080
790
itself to download less data.
1081
:param accelerator_tree: A tree which can be used for retrieving file
1082
contents more quickly than the revision tree, i.e. a workingtree.
1083
The revision tree will be used for cases where accelerator_tree's
1084
content is different.
1085
:param hardlink: If true, hard-link files from accelerator_tree,
1087
:param stacked: If true, create a stacked branch referring to the
1088
location of this control directory.
1090
792
target_transport = get_transport(url, possible_transports)
1091
793
target_transport.ensure_base()
1092
cloning_format = self.cloning_metadir(stacked)
1093
# Create/update the result branch
794
cloning_format = self.cloning_metadir()
1094
795
result = cloning_format.initialize_on_transport(target_transport)
1096
797
source_branch = self.open_branch()
1097
798
source_repository = source_branch.repository
1099
stacked_branch_url = self.root_transport.base
1101
# if a stacked branch wasn't requested, we don't create one
1102
# even if the origin was stacked
1103
stacked_branch_url = None
1104
799
except errors.NotBranchError:
1105
800
source_branch = None
1107
802
source_repository = self.open_repository()
1108
803
except errors.NoRepositoryPresent:
1109
804
source_repository = None
1110
stacked_branch_url = None
1111
repository_policy = result.determine_repository_policy(
1112
force_new_repo, stacked_branch_url, require_stacking=stacked)
1113
result_repo = repository_policy.acquire_repository()
1114
if source_repository is not None:
1115
# Fetch while stacked to prevent unstacked fetch from
1117
result_repo.fetch(source_repository, revision_id=revision_id)
1119
if source_branch is None:
1120
# this is for sprouting a bzrdir without a branch; is that
1122
# Not especially, but it's part of the contract.
1123
result_branch = result.create_branch()
1125
# Force NULL revision to avoid using repository before stacking
1127
result_branch = source_branch.sprout(
1128
result, revision_id=_mod_revision.NULL_REVISION)
1129
parent_location = result_branch.get_parent()
1130
mutter("created new branch %r" % (result_branch,))
1131
repository_policy.configure_branch(result_branch)
809
result_repo = result.find_repository()
810
except errors.NoRepositoryPresent:
812
if source_repository is None and result_repo is not None:
814
elif source_repository is None and result_repo is None:
815
# no repo available, make a new one
816
result.create_repository()
817
elif source_repository is not None and result_repo is None:
818
# have source, and want to make a new target repo
819
result_repo = source_repository.sprout(result,
820
revision_id=revision_id)
822
# fetch needed content into target.
823
if source_repository is not None:
825
# source_repository.copy_content_into(result_repo,
826
# revision_id=revision_id)
827
# so we can override the copy method
828
result_repo.fetch(source_repository, revision_id=revision_id)
1132
829
if source_branch is not None:
1133
source_branch.copy_content_into(result_branch, revision_id)
1134
# Override copy_content_into
1135
result_branch.set_parent(parent_location)
1137
# Create/update the result working tree
830
source_branch.sprout(result, revision_id=revision_id)
832
result.create_branch()
1138
833
if isinstance(target_transport, LocalTransport) and (
1139
834
result_repo is None or result_repo.make_working_trees()):
1140
wt = result.create_workingtree(accelerator_tree=accelerator_tree,
835
wt = result.create_workingtree()
1144
838
if wt.path2id('') is None:
1191
888
"""Pre-splitout bzrdirs do not suffer from stale locks."""
1192
889
raise NotImplementedError(self.break_lock)
1194
def cloning_metadir(self, require_stacking=False):
1195
"""Produce a metadir suitable for cloning with."""
1196
if require_stacking:
1197
return format_registry.make_bzrdir('1.6')
1198
return self._format.__class__()
1200
def clone(self, url, revision_id=None, force_new_repo=False,
1201
preserve_stacking=False):
1202
"""See BzrDir.clone().
1204
force_new_repo has no effect, since this family of formats always
1205
require a new repository.
1206
preserve_stacking has no effect, since no source branch using this
1207
family of formats can be stacked, so there is no stacking to preserve.
891
def clone(self, url, revision_id=None, force_new_repo=False):
892
"""See BzrDir.clone()."""
893
from bzrlib.workingtree import WorkingTreeFormat2
1209
894
self._make_tail(url)
1210
895
result = self._format._initialize_for_clone(url)
1211
896
self.open_repository().clone(result, revision_id=revision_id)
1212
897
from_branch = self.open_branch()
1213
898
from_branch.clone(result, revision_id=revision_id)
1215
tree = self.open_workingtree()
900
self.open_workingtree().clone(result)
1216
901
except errors.NotLocalUrl:
1217
902
# make a new one, this format always has to have one.
1218
result._init_workingtree()
904
WorkingTreeFormat2().initialize(result)
905
except errors.NotLocalUrl:
906
# but we cannot do it for remote trees.
907
to_branch = result.open_branch()
908
WorkingTreeFormat2().stub_initialize_remote(to_branch.control_files)
1223
911
def create_branch(self):
1224
912
"""See BzrDir.create_branch."""
1225
return self._format.get_branch_format().initialize(self)
913
return self.open_branch()
1227
915
def destroy_branch(self):
1228
916
"""See BzrDir.destroy_branch."""
1439
1100
"""See BzrDir.create_repository."""
1440
1101
return self._format.repository_format.initialize(self, shared)
1442
def destroy_repository(self):
1443
"""See BzrDir.destroy_repository."""
1444
self.transport.delete_tree('repository')
1446
def create_workingtree(self, revision_id=None, from_branch=None,
1447
accelerator_tree=None, hardlink=False):
1103
def create_workingtree(self, revision_id=None):
1448
1104
"""See BzrDir.create_workingtree."""
1449
return self._format.workingtree_format.initialize(
1450
self, revision_id, from_branch=from_branch,
1451
accelerator_tree=accelerator_tree, hardlink=hardlink)
1105
from bzrlib.workingtree import WorkingTreeFormat
1106
return self._format.workingtree_format.initialize(self, revision_id)
1453
1108
def destroy_workingtree(self):
1454
1109
"""See BzrDir.destroy_workingtree."""
1696
1348
# FIXME: RBC 20060121 don't peek under
1698
1350
mode=temp_control._dir_mode)
1699
if sys.platform == 'win32' and isinstance(transport, LocalTransport):
1700
win32utils.set_file_attr_hidden(transport._abspath('.bzr'))
1701
1351
file_mode = temp_control._file_mode
1702
1352
del temp_control
1703
bzrdir_transport = transport.clone('.bzr')
1704
utf8_files = [('README',
1705
"This is a Bazaar control directory.\n"
1706
"Do not change any files in this directory.\n"
1707
"See http://bazaar-vcs.org/ for more information about Bazaar.\n"),
1353
mutter('created control directory in ' + transport.base)
1354
control = transport.clone('.bzr')
1355
utf8_files = [('README',
1356
"This is a Bazaar-NG control directory.\n"
1357
"Do not change any files in this directory.\n"),
1708
1358
('branch-format', self.get_format_string()),
1710
1360
# NB: no need to escape relative paths that are url safe.
1711
control_files = lockable_files.LockableFiles(bzrdir_transport,
1712
self._lock_file_name, self._lock_class)
1361
control_files = lockable_files.LockableFiles(control,
1362
self._lock_file_name, self._lock_class)
1713
1363
control_files.create_lock()
1714
1364
control_files.lock_write()
1716
for (filename, content) in utf8_files:
1717
bzrdir_transport.put_bytes(filename, content,
1366
for file, content in utf8_files:
1367
control_files.put_utf8(file, content)
1720
1369
control_files.unlock()
1721
1370
return self.open(transport, _found=True)
2204
1860
self.bzrdir.transport.mkdir('revision-store')
2205
1861
revision_transport = self.bzrdir.transport.clone('revision-store')
2206
1862
# TODO permissions
2207
from bzrlib.xml5 import serializer_v5
2208
from bzrlib.repofmt.weaverepo import RevisionTextStore
2209
revision_store = RevisionTextStore(revision_transport,
2210
serializer_v5, False, versionedfile.PrefixMapper(),
2211
lambda:True, lambda:True)
1863
_revision_store = TextRevisionStore(TextStore(revision_transport,
1867
transaction = WriteTransaction()
2213
1868
for i, rev_id in enumerate(self.converted_revs):
2214
1869
self.pb.update('write revision', i, len(self.converted_revs))
2215
text = serializer_v5.write_revision_to_string(
2216
self.revisions[rev_id])
2218
revision_store.add_lines(key, None, osutils.split_lines(text))
1870
_revision_store.add_revision(self.revisions[rev_id], transaction)
2220
1872
self.pb.clear()
2235
1887
self.absent_revisions.add(rev_id)
2237
rev = self.branch.repository.get_revision(rev_id)
1889
rev = self.branch.repository._revision_store.get_revision(rev_id,
1890
self.branch.repository.get_transaction())
2238
1891
for parent_id in rev.parent_ids:
2239
1892
self.known_revisions.add(parent_id)
2240
1893
self.to_read.append(parent_id)
2241
1894
self.revisions[rev_id] = rev
2243
1896
def _load_old_inventory(self, rev_id):
1897
assert rev_id not in self.converted_revs
2244
1898
old_inv_xml = self.branch.repository.inventory_store.get(rev_id).read()
2245
1899
inv = xml4.serializer_v4.read_inventory_from_string(old_inv_xml)
2246
1900
inv.revision_id = rev_id
2247
1901
rev = self.revisions[rev_id]
1902
if rev.inventory_sha1:
1903
assert rev.inventory_sha1 == sha_string(old_inv_xml), \
1904
'inventory sha mismatch for {%s}' % rev_id
2250
1907
def _load_updated_inventory(self, rev_id):
1908
assert rev_id in self.converted_revs
2251
1909
inv_xml = self.inv_weave.get_text(rev_id)
2252
inv = xml5.serializer_v5.read_inventory_from_string(inv_xml, rev_id)
1910
inv = xml5.serializer_v5.read_inventory_from_string(inv_xml)
2255
1913
def _convert_one_rev(self, rev_id):
2305
1975
self.snapshot_ie(previous_entries, ie, w, rev_id)
1977
assert getattr(ie, 'revision', None) is not None
2308
@symbol_versioning.deprecated_method(symbol_versioning.one_one)
2309
1979
def get_parents(self, revision_ids):
2310
1980
for revision_id in revision_ids:
2311
1981
yield self.revisions[revision_id].parent_ids
2313
def get_parent_map(self, revision_ids):
2314
"""See graph._StackedParentsProvider.get_parent_map"""
2315
return dict((revision_id, self.revisions[revision_id])
2316
for revision_id in revision_ids
2317
if revision_id in self.revisions)
2319
1983
def snapshot_ie(self, previous_revisions, ie, w, rev_id):
2320
1984
# TODO: convert this logic, which is ~= snapshot to
2321
1985
# a call to:. This needs the path figured out. rather than a work_tree
2384
2050
if (filename.endswith(".weave") or
2385
2051
filename.endswith(".gz") or
2386
2052
filename.endswith(".sig")):
2387
file_id, suffix = os.path.splitext(filename)
2053
file_id = os.path.splitext(filename)[0]
2389
2055
file_id = filename
2391
new_name = store._mapper.map((file_id,)) + suffix
2056
prefix_dir = store.hash_prefix(file_id)
2392
2057
# FIXME keep track of the dirs made RBC 20060121
2394
store_transport.move(filename, new_name)
2059
store_transport.move(filename, prefix_dir + '/' + filename)
2395
2060
except errors.NoSuchFile: # catches missing dirs strangely enough
2396
store_transport.mkdir(osutils.dirname(new_name))
2397
store_transport.move(filename, new_name)
2398
self.bzrdir.transport.put_bytes(
2400
BzrDirFormat6().get_format_string(),
2401
mode=self.bzrdir._get_file_mode())
2061
store_transport.mkdir(prefix_dir)
2062
store_transport.move(filename, prefix_dir + '/' + filename)
2063
self.bzrdir._control_files.put_utf8('branch-format', BzrDirFormat6().get_format_string())
2404
2066
class ConvertBzrDir6ToMeta(Converter):
2558
2213
# TODO: conversions of Branch and Tree should be done by
2559
# InterXFormat lookups/some sort of registry.
2214
# InterXFormat lookups
2560
2215
# Avoid circular imports
2561
2216
from bzrlib import branch as _mod_branch
2562
old = branch._format.__class__
2563
new = self.target_format.get_branch_format().__class__
2565
if (old == _mod_branch.BzrBranchFormat5 and
2566
new in (_mod_branch.BzrBranchFormat6,
2567
_mod_branch.BzrBranchFormat7)):
2568
branch_converter = _mod_branch.Converter5to6()
2569
elif (old == _mod_branch.BzrBranchFormat6 and
2570
new == _mod_branch.BzrBranchFormat7):
2571
branch_converter = _mod_branch.Converter6to7()
2573
raise errors.BadConversionTarget("No converter", new)
2217
if (branch._format.__class__ is _mod_branch.BzrBranchFormat5 and
2218
self.target_format.get_branch_format().__class__ is
2219
_mod_branch.BzrBranchFormat6):
2220
branch_converter = _mod_branch.Converter5to6()
2574
2221
branch_converter.convert(branch)
2575
branch = self.bzrdir.open_branch()
2576
old = branch._format.__class__
2578
2223
tree = self.bzrdir.open_workingtree(recommend_upgrade=False)
2579
2224
except (errors.NoWorkingTree, errors.NotLocalUrl):
2603
2248
def probe_transport(klass, transport):
2604
2249
"""Return a RemoteBzrDirFormat object if it looks possible."""
2606
medium = transport.get_smart_medium()
2251
client = transport.get_smart_client()
2607
2252
except (NotImplementedError, AttributeError,
2608
errors.TransportNotPossible, errors.NoSmartMedium,
2609
errors.SmartProtocolError):
2253
errors.TransportNotPossible):
2610
2254
# no smart server, so not a branch for this format type.
2611
2255
raise errors.NotBranchError(path=transport.base)
2613
# Decline to open it if the server doesn't support our required
2614
# version (3) so that the VFS-based transport will do it.
2615
if medium.should_probe():
2617
server_version = medium.protocol_version()
2618
except errors.SmartProtocolError:
2619
# Apparently there's no usable smart server there, even though
2620
# the medium supports the smart protocol.
2621
raise errors.NotBranchError(path=transport.base)
2622
if server_version != '2':
2623
raise errors.NotBranchError(path=transport.base)
2257
# Send a 'hello' request in protocol version one, and decline to
2258
# open it if the server doesn't support our required version (2) so
2259
# that the VFS-based transport will do it.
2260
request = client.get_request()
2261
smart_protocol = protocol.SmartClientRequestProtocolOne(request)
2262
server_version = smart_protocol.query_version()
2263
if server_version != 2:
2264
raise errors.NotBranchError(path=transport.base)
2626
2267
def initialize_on_transport(self, transport):
2628
2269
# hand off the request to the smart server
2629
client_medium = transport.get_smart_medium()
2270
shared_medium = transport.get_shared_medium()
2630
2271
except errors.NoSmartMedium:
2631
2272
# TODO: lookup the local format from a server hint.
2632
2273
local_dir_format = BzrDirMetaFormat1()
2633
2274
return local_dir_format.initialize_on_transport(transport)
2634
client = _SmartClient(client_medium)
2275
client = _SmartClient(shared_medium)
2635
2276
path = client.remote_path_from_transport(transport)
2636
response = client.call('BzrDirFormat.initialize', path)
2637
if response[0] != 'ok':
2638
raise errors.SmartProtocolError('unexpected response code %s' % (response,))
2277
response = _SmartClient(shared_medium).call('BzrDirFormat.initialize',
2279
assert response[0] in ('ok', ), 'unexpected response code %s' % (response,)
2639
2280
return remote.RemoteBzrDir(transport)
2641
2282
def _open(self, transport):
2732
2363
This function mainly exists to prevent the info object from being
2733
2364
supplied directly.
2735
registry.Registry.register(self, key, factory, help,
2366
registry.Registry.register(self, key, factory, help,
2736
2367
BzrDirFormatInfo(native, deprecated, hidden, experimental))
2738
self._aliases.add(key)
2740
2369
def register_lazy(self, key, module_name, member_name, help, native=True,
2741
deprecated=False, hidden=False, experimental=False, alias=False):
2742
registry.Registry.register_lazy(self, key, module_name, member_name,
2370
deprecated=False, hidden=False, experimental=False):
2371
registry.Registry.register_lazy(self, key, module_name, member_name,
2743
2372
help, BzrDirFormatInfo(native, deprecated, hidden, experimental))
2745
self._aliases.add(key)
2747
2374
def set_default(self, key):
2748
2375
"""Set the 'default' key to be a clone of the supplied key.
2750
2377
This method must be called once and only once.
2752
registry.Registry.register(self, 'default', self.get(key),
2379
registry.Registry.register(self, 'default', self.get(key),
2753
2380
self.get_help(key), info=self.get_info(key))
2754
self._aliases.add('default')
2756
2382
def set_default_repository(self, key):
2757
2383
"""Set the FormatRegistry default and Repository default.
2823
class RepositoryAcquisitionPolicy(object):
2824
"""Abstract base class for repository acquisition policies.
2826
A repository acquisition policy decides how a BzrDir acquires a repository
2827
for a branch that is being created. The most basic policy decision is
2828
whether to create a new repository or use an existing one.
2830
def __init__(self, stack_on, stack_on_pwd, require_stacking):
2833
:param stack_on: A location to stack on
2834
:param stack_on_pwd: If stack_on is relative, the location it is
2836
:param require_stacking: If True, it is a failure to not stack.
2838
self._stack_on = stack_on
2839
self._stack_on_pwd = stack_on_pwd
2840
self._require_stacking = require_stacking
2842
def configure_branch(self, branch):
2843
"""Apply any configuration data from this policy to the branch.
2845
Default implementation sets repository stacking.
2847
if self._stack_on is None:
2849
if self._stack_on_pwd is None:
2850
stack_on = self._stack_on
2853
stack_on = urlutils.rebase_url(self._stack_on,
2855
branch.bzrdir.root_transport.base)
2856
except errors.InvalidRebaseURLs:
2857
stack_on = self._get_full_stack_on()
2859
branch.set_stacked_on_url(stack_on)
2860
except errors.UnstackableBranchFormat:
2861
if self._require_stacking:
2864
def _get_full_stack_on(self):
2865
"""Get a fully-qualified URL for the stack_on location."""
2866
if self._stack_on is None:
2868
if self._stack_on_pwd is None:
2869
return self._stack_on
2871
return urlutils.join(self._stack_on_pwd, self._stack_on)
2873
def _add_fallback(self, repository):
2874
"""Add a fallback to the supplied repository, if stacking is set."""
2875
stack_on = self._get_full_stack_on()
2876
if stack_on is None:
2878
stacked_dir = BzrDir.open(stack_on)
2880
stacked_repo = stacked_dir.open_branch().repository
2881
except errors.NotBranchError:
2882
stacked_repo = stacked_dir.open_repository()
2884
repository.add_fallback_repository(stacked_repo)
2885
except errors.UnstackableRepositoryFormat:
2886
if self._require_stacking:
2889
def acquire_repository(self, make_working_trees=None, shared=False):
2890
"""Acquire a repository for this bzrdir.
2892
Implementations may create a new repository or use a pre-exising
2894
:param make_working_trees: If creating a repository, set
2895
make_working_trees to this value (if non-None)
2896
:param shared: If creating a repository, make it shared if True
2897
:return: A repository
2899
raise NotImplemented(RepositoryAcquisitionPolicy.acquire_repository)
2902
class CreateRepository(RepositoryAcquisitionPolicy):
2903
"""A policy of creating a new repository"""
2905
def __init__(self, bzrdir, stack_on=None, stack_on_pwd=None,
2906
require_stacking=False):
2909
:param bzrdir: The bzrdir to create the repository on.
2910
:param stack_on: A location to stack on
2911
:param stack_on_pwd: If stack_on is relative, the location it is
2914
RepositoryAcquisitionPolicy.__init__(self, stack_on, stack_on_pwd,
2916
self._bzrdir = bzrdir
2918
def acquire_repository(self, make_working_trees=None, shared=False):
2919
"""Implementation of RepositoryAcquisitionPolicy.acquire_repository
2921
Creates the desired repository in the bzrdir we already have.
2923
repository = self._bzrdir.create_repository(shared=shared)
2924
self._add_fallback(repository)
2925
if make_working_trees is not None:
2926
repository.set_make_working_trees(make_working_trees)
2930
class UseExistingRepository(RepositoryAcquisitionPolicy):
2931
"""A policy of reusing an existing repository"""
2933
def __init__(self, repository, stack_on=None, stack_on_pwd=None,
2934
require_stacking=False):
2937
:param repository: The repository to use.
2938
:param stack_on: A location to stack on
2939
:param stack_on_pwd: If stack_on is relative, the location it is
2942
RepositoryAcquisitionPolicy.__init__(self, stack_on, stack_on_pwd,
2944
self._repository = repository
2946
def acquire_repository(self, make_working_trees=None, shared=False):
2947
"""Implementation of RepositoryAcquisitionPolicy.acquire_repository
2949
Returns an existing repository to use
2951
self._add_fallback(self._repository)
2952
return self._repository
2955
2450
format_registry = BzrDirFormatRegistry()
2956
2451
format_registry.register('weave', BzrDirFormat6,
2957
2452
'Pre-0.8 format. Slower than knit and does not'
2999
2487
'bzr branches. Incompatible with bzr < 0.15.',
3000
2488
branch_format='bzrlib.branch.BzrBranchFormat6',
3001
2489
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3005
format_registry.register_metadir('pack-0.92',
2492
format_registry.register_metadir('knitpack-experimental',
3006
2493
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack1',
3007
2494
help='New in 0.92: Pack-based format with data compatible with '
3008
2495
'dirstate-tags format repositories. Interoperates with '
3009
2496
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3010
'Previously called knitpack-experimental. '
3011
'For more information, see '
3012
'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
2497
'NOTE: This format is experimental. Before using it, please read '
2498
'http://doc.bazaar-vcs.org/latest/developers/knitpack.html.',
3013
2499
branch_format='bzrlib.branch.BzrBranchFormat6',
3014
2500
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3016
format_registry.register_metadir('pack-0.92-subtree',
2503
format_registry.register_metadir('knitpack-subtree-experimental',
3017
2504
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack3',
3018
2505
help='New in 0.92: Pack-based format with data compatible with '
3019
2506
'dirstate-with-subtree format repositories. Interoperates with '
3020
2507
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3021
'Previously called knitpack-experimental. '
3022
'For more information, see '
3023
'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
3024
branch_format='bzrlib.branch.BzrBranchFormat6',
3025
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3029
format_registry.register_metadir('rich-root-pack',
3030
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack4',
3031
help='New in 1.0: Pack-based format with data compatible with '
3032
'rich-root format repositories. Incompatible with'
3034
branch_format='bzrlib.branch.BzrBranchFormat6',
3035
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3037
format_registry.register_metadir('1.6',
3038
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5',
3039
help='A branch and pack based repository that supports stacking. ',
3040
branch_format='bzrlib.branch.BzrBranchFormat7',
3041
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3043
format_registry.register_metadir('1.6.1-rich-root',
3044
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5RichRoot',
3045
help='A branch and pack based repository that supports stacking '
3046
'and rich root data (needed for bzr-svn). ',
3047
branch_format='bzrlib.branch.BzrBranchFormat7',
3048
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3050
# The following two formats should always just be aliases.
3051
format_registry.register_metadir('development',
3052
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment1',
3053
help='Current development format. Can convert data to and from pack-0.92 '
3054
'(and anything compatible with pack-0.92) format repositories. '
3055
'Repositories and branches in this format can only be read by bzr.dev. '
3057
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3059
branch_format='bzrlib.branch.BzrBranchFormat7',
3060
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3064
format_registry.register_metadir('development-subtree',
3065
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment1Subtree',
3066
help='Current development format, subtree variant. Can convert data to and '
3067
'from pack-0.92-subtree (and anything compatible with '
3068
'pack-0.92-subtree) format repositories. Repositories and branches in '
3069
'this format can only be read by bzr.dev. Please read '
3070
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3072
branch_format='bzrlib.branch.BzrBranchFormat7',
3073
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3077
# And the development formats which the will have aliased one of follow:
3078
format_registry.register_metadir('development1',
3079
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment1',
3080
help='A branch and pack based repository that supports stacking. '
3082
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3084
branch_format='bzrlib.branch.BzrBranchFormat7',
3085
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3089
format_registry.register_metadir('development1-subtree',
3090
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment1Subtree',
3091
help='A branch and pack based repository that supports stacking. '
3093
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3095
branch_format='bzrlib.branch.BzrBranchFormat7',
3096
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3100
# The current format that is made on 'bzr init'.
3101
format_registry.set_default('pack-0.92')
2508
'NOTE: This format is experimental. Before using it, please read '
2509
'http://doc.bazaar-vcs.org/latest/developers/knitpack.html.',
2510
branch_format='bzrlib.branch.BzrBranchFormat6',
2511
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2515
format_registry.set_default('dirstate-tags')
added
removed
bzrlib/bzrdir.py
