1
# Copyright (C) 2005, 2006 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
"""BzrDir logic. The BzrDir is the basic control directory used by bzr.
19
At format 7 this was split out into Branch, Repository and Checkout control
23
# TODO: remove unittest dependency; put that stuff inside the test suite
25
# TODO: The Format probe_transport seems a bit redundant with just trying to
26
# open the bzrdir. -- mbp
28
# TODO: Can we move specific formats into separate modules to make this file
31
from cStringIO import StringIO
34
from bzrlib.lazy_import import lazy_import
35
lazy_import(globals(), """
36
from copy import deepcopy
37
from stat import S_ISDIR
45
revision as _mod_revision,
50
from bzrlib.osutils import (
55
from bzrlib.store.revision.text import TextRevisionStore
56
from bzrlib.store.text import TextStore
57
from bzrlib.store.versioned import WeaveStore
58
from bzrlib.transactions import WriteTransaction
59
from bzrlib.transport import get_transport
60
from bzrlib.weave import Weave
63
from bzrlib.trace import mutter
64
from bzrlib.transport.local import LocalTransport
68
"""A .bzr control diretory.
70
BzrDir instances let you create or open any of the things that can be
71
found within .bzr - checkouts, branches and repositories.
74
the transport which this bzr dir is rooted at (i.e. file:///.../.bzr/)
76
a transport connected to the directory this bzr was opened from.
80
"""Invoke break_lock on the first object in the bzrdir.
82
If there is a tree, the tree is opened and break_lock() called.
83
Otherwise, branch is tried, and finally repository.
86
thing_to_unlock = self.open_workingtree()
87
except (errors.NotLocalUrl, errors.NoWorkingTree):
89
thing_to_unlock = self.open_branch()
90
except errors.NotBranchError:
92
thing_to_unlock = self.open_repository()
93
except errors.NoRepositoryPresent:
95
thing_to_unlock.break_lock()
97
def can_convert_format(self):
98
"""Return true if this bzrdir is one whose format we can convert from."""
101
def check_conversion_target(self, target_format):
102
target_repo_format = target_format.repository_format
103
source_repo_format = self._format.repository_format
104
source_repo_format.check_conversion_target(target_repo_format)
107
def _check_supported(format, allow_unsupported):
108
"""Check whether format is a supported format.
110
If allow_unsupported is True, this is a no-op.
112
if not allow_unsupported and not format.is_supported():
113
# see open_downlevel to open legacy branches.
114
raise errors.UnsupportedFormatError(format=format)
116
def clone(self, url, revision_id=None, basis=None, force_new_repo=False):
117
"""Clone this bzrdir and its contents to url verbatim.
119
If urls last component does not exist, it will be created.
121
if revision_id is not None, then the clone operation may tune
122
itself to download less data.
123
:param force_new_repo: Do not use a shared repository for the target
124
even if one is available.
127
basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
128
result = self._format.initialize(url)
130
local_repo = self.find_repository()
131
except errors.NoRepositoryPresent:
134
# may need to copy content in
136
result_repo = local_repo.clone(
138
revision_id=revision_id,
140
result_repo.set_make_working_trees(local_repo.make_working_trees())
143
result_repo = result.find_repository()
144
# fetch content this dir needs.
146
# XXX FIXME RBC 20060214 need tests for this when the basis
148
result_repo.fetch(basis_repo, revision_id=revision_id)
149
result_repo.fetch(local_repo, revision_id=revision_id)
150
except errors.NoRepositoryPresent:
151
# needed to make one anyway.
152
result_repo = local_repo.clone(
154
revision_id=revision_id,
156
result_repo.set_make_working_trees(local_repo.make_working_trees())
157
# 1 if there is a branch present
158
# make sure its content is available in the target repository
161
self.open_branch().clone(result, revision_id=revision_id)
162
except errors.NotBranchError:
165
self.open_workingtree().clone(result, basis=basis_tree)
166
except (errors.NoWorkingTree, errors.NotLocalUrl):
170
def _get_basis_components(self, basis):
171
"""Retrieve the basis components that are available at basis."""
173
return None, None, None
175
basis_tree = basis.open_workingtree()
176
basis_branch = basis_tree.branch
177
basis_repo = basis_branch.repository
178
except (errors.NoWorkingTree, errors.NotLocalUrl):
181
basis_branch = basis.open_branch()
182
basis_repo = basis_branch.repository
183
except errors.NotBranchError:
186
basis_repo = basis.open_repository()
187
except errors.NoRepositoryPresent:
189
return basis_repo, basis_branch, basis_tree
191
# TODO: This should be given a Transport, and should chdir up; otherwise
192
# this will open a new connection.
193
def _make_tail(self, url):
194
head, tail = urlutils.split(url)
195
if tail and tail != '.':
196
t = get_transport(head)
199
except errors.FileExists:
202
# TODO: Should take a Transport
204
def create(cls, base):
205
"""Create a new BzrDir at the url 'base'.
207
This will call the current default formats initialize with base
208
as the only parameter.
210
If you need a specific format, consider creating an instance
211
of that and calling initialize().
213
if cls is not BzrDir:
214
raise AssertionError("BzrDir.create always creates the default format, "
215
"not one of %r" % cls)
216
head, tail = urlutils.split(base)
217
if tail and tail != '.':
218
t = get_transport(head)
221
except errors.FileExists:
223
return BzrDirFormat.get_default_format().initialize(safe_unicode(base))
225
def create_branch(self):
226
"""Create a branch in this BzrDir.
228
The bzrdirs format will control what branch format is created.
229
For more control see BranchFormatXX.create(a_bzrdir).
231
raise NotImplementedError(self.create_branch)
234
def create_branch_and_repo(base, force_new_repo=False):
235
"""Create a new BzrDir, Branch and Repository at the url 'base'.
237
This will use the current default BzrDirFormat, and use whatever
238
repository format that that uses via bzrdir.create_branch and
239
create_repository. If a shared repository is available that is used
242
The created Branch object is returned.
244
:param base: The URL to create the branch at.
245
:param force_new_repo: If True a new repository is always created.
247
bzrdir = BzrDir.create(base)
248
bzrdir._find_or_create_repository(force_new_repo)
249
return bzrdir.create_branch()
251
def _find_or_create_repository(self, force_new_repo):
252
"""Create a new repository if needed, returning the repository."""
254
return self.create_repository()
256
return self.find_repository()
257
except errors.NoRepositoryPresent:
258
return self.create_repository()
261
def create_branch_convenience(base, force_new_repo=False,
262
force_new_tree=None, format=None):
263
"""Create a new BzrDir, Branch and Repository at the url 'base'.
265
This is a convenience function - it will use an existing repository
266
if possible, can be told explicitly whether to create a working tree or
269
This will use the current default BzrDirFormat, and use whatever
270
repository format that that uses via bzrdir.create_branch and
271
create_repository. If a shared repository is available that is used
272
preferentially. Whatever repository is used, its tree creation policy
275
The created Branch object is returned.
276
If a working tree cannot be made due to base not being a file:// url,
277
no error is raised unless force_new_tree is True, in which case no
278
data is created on disk and NotLocalUrl is raised.
280
:param base: The URL to create the branch at.
281
:param force_new_repo: If True a new repository is always created.
282
:param force_new_tree: If True or False force creation of a tree or
283
prevent such creation respectively.
284
:param format: Override for the for the bzrdir format to create
287
# check for non local urls
288
t = get_transport(safe_unicode(base))
289
if not isinstance(t, LocalTransport):
290
raise errors.NotLocalUrl(base)
292
bzrdir = BzrDir.create(base)
294
bzrdir = format.initialize(base)
295
repo = bzrdir._find_or_create_repository(force_new_repo)
296
result = bzrdir.create_branch()
297
if force_new_tree or (repo.make_working_trees() and
298
force_new_tree is None):
300
bzrdir.create_workingtree()
301
except errors.NotLocalUrl:
306
def create_repository(base, shared=False):
307
"""Create a new BzrDir and Repository at the url 'base'.
309
This will use the current default BzrDirFormat, and use whatever
310
repository format that that uses for bzrdirformat.create_repository.
312
:param shared: Create a shared repository rather than a standalone
314
The Repository object is returned.
316
This must be overridden as an instance method in child classes, where
317
it should take no parameters and construct whatever repository format
318
that child class desires.
320
bzrdir = BzrDir.create(base)
321
return bzrdir.create_repository(shared)
324
def create_standalone_workingtree(base):
325
"""Create a new BzrDir, WorkingTree, Branch and Repository at 'base'.
327
'base' must be a local path or a file:// url.
329
This will use the current default BzrDirFormat, and use whatever
330
repository format that that uses for bzrdirformat.create_workingtree,
331
create_branch and create_repository.
333
:return: The WorkingTree object.
335
t = get_transport(safe_unicode(base))
336
if not isinstance(t, LocalTransport):
337
raise errors.NotLocalUrl(base)
338
bzrdir = BzrDir.create_branch_and_repo(safe_unicode(base),
339
force_new_repo=True).bzrdir
340
return bzrdir.create_workingtree()
342
def create_workingtree(self, revision_id=None):
343
"""Create a working tree at this BzrDir.
345
revision_id: create it as of this revision id.
347
raise NotImplementedError(self.create_workingtree)
349
def destroy_workingtree(self):
350
"""Destroy the working tree at this BzrDir.
352
Formats that do not support this may raise UnsupportedOperation.
354
raise NotImplementedError(self.destroy_workingtree)
356
def destroy_workingtree_metadata(self):
357
"""Destroy the control files for the working tree at this BzrDir.
359
The contents of working tree files are not affected.
360
Formats that do not support this may raise UnsupportedOperation.
362
raise NotImplementedError(self.destroy_workingtree_metadata)
364
def find_repository(self):
365
"""Find the repository that should be used for a_bzrdir.
367
This does not require a branch as we use it to find the repo for
368
new branches as well as to hook existing branches up to their
372
return self.open_repository()
373
except errors.NoRepositoryPresent:
375
next_transport = self.root_transport.clone('..')
377
# find the next containing bzrdir
379
found_bzrdir = BzrDir.open_containing_from_transport(
381
except errors.NotBranchError:
383
raise errors.NoRepositoryPresent(self)
384
# does it have a repository ?
386
repository = found_bzrdir.open_repository()
387
except errors.NoRepositoryPresent:
388
next_transport = found_bzrdir.root_transport.clone('..')
389
if (found_bzrdir.root_transport.base == next_transport.base):
390
# top of the file system
394
if ((found_bzrdir.root_transport.base ==
395
self.root_transport.base) or repository.is_shared()):
398
raise errors.NoRepositoryPresent(self)
399
raise errors.NoRepositoryPresent(self)
401
def get_branch_transport(self, branch_format):
402
"""Get the transport for use by branch format in this BzrDir.
404
Note that bzr dirs that do not support format strings will raise
405
IncompatibleFormat if the branch format they are given has
406
a format string, and vice versa.
408
If branch_format is None, the transport is returned with no
409
checking. if it is not None, then the returned transport is
410
guaranteed to point to an existing directory ready for use.
412
raise NotImplementedError(self.get_branch_transport)
414
def get_repository_transport(self, repository_format):
415
"""Get the transport for use by repository format in this BzrDir.
417
Note that bzr dirs that do not support format strings will raise
418
IncompatibleFormat if the repository format they are given has
419
a format string, and vice versa.
421
If repository_format is None, the transport is returned with no
422
checking. if it is not None, then the returned transport is
423
guaranteed to point to an existing directory ready for use.
425
raise NotImplementedError(self.get_repository_transport)
427
def get_workingtree_transport(self, tree_format):
428
"""Get the transport for use by workingtree format in this BzrDir.
430
Note that bzr dirs that do not support format strings will raise
431
IncompatibleFormat if the workingtree format they are given has
432
a format string, and vice versa.
434
If workingtree_format is None, the transport is returned with no
435
checking. if it is not None, then the returned transport is
436
guaranteed to point to an existing directory ready for use.
438
raise NotImplementedError(self.get_workingtree_transport)
440
def __init__(self, _transport, _format):
441
"""Initialize a Bzr control dir object.
443
Only really common logic should reside here, concrete classes should be
444
made with varying behaviours.
446
:param _format: the format that is creating this BzrDir instance.
447
:param _transport: the transport this dir is based at.
449
self._format = _format
450
self.transport = _transport.clone('.bzr')
451
self.root_transport = _transport
453
def is_control_filename(self, filename):
454
"""True if filename is the name of a path which is reserved for bzrdir's.
456
:param filename: A filename within the root transport of this bzrdir.
458
This is true IF and ONLY IF the filename is part of the namespace reserved
459
for bzr control dirs. Currently this is the '.bzr' directory in the root
460
of the root_transport. it is expected that plugins will need to extend
461
this in the future - for instance to make bzr talk with svn working
464
# this might be better on the BzrDirFormat class because it refers to
465
# all the possible bzrdir disk formats.
466
# This method is tested via the workingtree is_control_filename tests-
467
# it was extracted from WorkingTree.is_control_filename. If the methods
468
# contract is extended beyond the current trivial implementation please
469
# add new tests for it to the appropriate place.
470
return filename == '.bzr' or filename.startswith('.bzr/')
472
def needs_format_conversion(self, format=None):
473
"""Return true if this bzrdir needs convert_format run on it.
475
For instance, if the repository format is out of date but the
476
branch and working tree are not, this should return True.
478
:param format: Optional parameter indicating a specific desired
479
format we plan to arrive at.
481
raise NotImplementedError(self.needs_format_conversion)
484
def open_unsupported(base):
485
"""Open a branch which is not supported."""
486
return BzrDir.open(base, _unsupported=True)
489
def open(base, _unsupported=False):
490
"""Open an existing bzrdir, rooted at 'base' (url)
492
_unsupported is a private parameter to the BzrDir class.
494
t = get_transport(base)
495
return BzrDir.open_from_transport(t, _unsupported=_unsupported)
498
def open_from_transport(transport, _unsupported=False):
499
"""Open a bzrdir within a particular directory.
501
:param transport: Transport containing the bzrdir.
502
:param _unsupported: private.
504
format = BzrDirFormat.find_format(transport)
505
BzrDir._check_supported(format, _unsupported)
506
return format.open(transport, _found=True)
508
def open_branch(self, unsupported=False):
509
"""Open the branch object at this BzrDir if one is present.
511
If unsupported is True, then no longer supported branch formats can
514
TODO: static convenience version of this?
516
raise NotImplementedError(self.open_branch)
519
def open_containing(url):
520
"""Open an existing branch which contains url.
522
:param url: url to search from.
523
See open_containing_from_transport for more detail.
525
return BzrDir.open_containing_from_transport(get_transport(url))
528
def open_containing_from_transport(a_transport):
529
"""Open an existing branch which contains a_transport.base
531
This probes for a branch at a_transport, and searches upwards from there.
533
Basically we keep looking up until we find the control directory or
534
run into the root. If there isn't one, raises NotBranchError.
535
If there is one and it is either an unrecognised format or an unsupported
536
format, UnknownFormatError or UnsupportedFormatError are raised.
537
If there is one, it is returned, along with the unused portion of url.
539
:return: The BzrDir that contains the path, and a Unicode path
540
for the rest of the URL.
542
# this gets the normalised url back. I.e. '.' -> the full path.
543
url = a_transport.base
546
result = BzrDir.open_from_transport(a_transport)
547
return result, urlutils.unescape(a_transport.relpath(url))
548
except errors.NotBranchError, e:
550
new_t = a_transport.clone('..')
551
if new_t.base == a_transport.base:
552
# reached the root, whatever that may be
553
raise errors.NotBranchError(path=url)
556
def open_repository(self, _unsupported=False):
557
"""Open the repository object at this BzrDir if one is present.
559
This will not follow the Branch object pointer - its strictly a direct
560
open facility. Most client code should use open_branch().repository to
563
_unsupported is a private parameter, not part of the api.
564
TODO: static convenience version of this?
566
raise NotImplementedError(self.open_repository)
568
def open_workingtree(self, _unsupported=False):
569
"""Open the workingtree object at this BzrDir if one is present.
571
TODO: static convenience version of this?
573
raise NotImplementedError(self.open_workingtree)
575
def has_branch(self):
576
"""Tell if this bzrdir contains a branch.
578
Note: if you're going to open the branch, you should just go ahead
579
and try, and not ask permission first. (This method just opens the
580
branch and discards it, and that's somewhat expensive.)
585
except errors.NotBranchError:
588
def has_workingtree(self):
589
"""Tell if this bzrdir contains a working tree.
591
This will still raise an exception if the bzrdir has a workingtree that
592
is remote & inaccessible.
594
Note: if you're going to open the working tree, you should just go ahead
595
and try, and not ask permission first. (This method just opens the
596
workingtree and discards it, and that's somewhat expensive.)
599
self.open_workingtree()
601
except errors.NoWorkingTree:
604
def cloning_metadir(self, basis=None):
605
"""Produce a metadir suitable for cloning with"""
606
def related_repository(bzrdir):
608
branch = bzrdir.open_branch()
609
return branch.repository
610
except errors.NotBranchError:
612
return bzrdir.open_repository()
613
result_format = self._format.__class__()
616
source_repository = related_repository(self)
617
except errors.NoRepositoryPresent:
620
source_repository = related_repository(self)
621
result_format.repository_format = source_repository._format
622
except errors.NoRepositoryPresent:
626
def sprout(self, url, revision_id=None, basis=None, force_new_repo=False):
627
"""Create a copy of this bzrdir prepared for use as a new line of
630
If urls last component does not exist, it will be created.
632
Attributes related to the identity of the source branch like
633
branch nickname will be cleaned, a working tree is created
634
whether one existed before or not; and a local branch is always
637
if revision_id is not None, then the clone operation may tune
638
itself to download less data.
641
cloning_format = self.cloning_metadir(basis)
642
result = cloning_format.initialize(url)
643
basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
645
source_branch = self.open_branch()
646
source_repository = source_branch.repository
647
except errors.NotBranchError:
650
source_repository = self.open_repository()
651
except errors.NoRepositoryPresent:
652
# copy the entire basis one if there is one
653
# but there is no repository.
654
source_repository = basis_repo
659
result_repo = result.find_repository()
660
except errors.NoRepositoryPresent:
662
if source_repository is None and result_repo is not None:
664
elif source_repository is None and result_repo is None:
665
# no repo available, make a new one
666
result.create_repository()
667
elif source_repository is not None and result_repo is None:
668
# have source, and want to make a new target repo
669
# we don't clone the repo because that preserves attributes
670
# like is_shared(), and we have not yet implemented a
671
# repository sprout().
672
result_repo = result.create_repository()
673
if result_repo is not None:
674
# fetch needed content into target.
676
# XXX FIXME RBC 20060214 need tests for this when the basis
678
result_repo.fetch(basis_repo, revision_id=revision_id)
679
if source_repository is not None:
680
result_repo.fetch(source_repository, revision_id=revision_id)
681
if source_branch is not None:
682
source_branch.sprout(result, revision_id=revision_id)
684
result.create_branch()
685
# TODO: jam 20060426 we probably need a test in here in the
686
# case that the newly sprouted branch is a remote one
687
if result_repo is None or result_repo.make_working_trees():
688
wt = result.create_workingtree()
689
if wt.inventory.root is None:
691
wt.set_root_id(self.open_workingtree.get_root_id())
692
except errors.NoWorkingTree:
697
class BzrDirPreSplitOut(BzrDir):
698
"""A common class for the all-in-one formats."""
700
def __init__(self, _transport, _format):
701
"""See BzrDir.__init__."""
702
super(BzrDirPreSplitOut, self).__init__(_transport, _format)
703
assert self._format._lock_class == lockable_files.TransportLock
704
assert self._format._lock_file_name == 'branch-lock'
705
self._control_files = lockable_files.LockableFiles(
706
self.get_branch_transport(None),
707
self._format._lock_file_name,
708
self._format._lock_class)
710
def break_lock(self):
711
"""Pre-splitout bzrdirs do not suffer from stale locks."""
712
raise NotImplementedError(self.break_lock)
714
def clone(self, url, revision_id=None, basis=None, force_new_repo=False):
715
"""See BzrDir.clone()."""
716
from bzrlib.workingtree import WorkingTreeFormat2
718
result = self._format._initialize_for_clone(url)
719
basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
720
self.open_repository().clone(result, revision_id=revision_id, basis=basis_repo)
721
from_branch = self.open_branch()
722
from_branch.clone(result, revision_id=revision_id)
724
self.open_workingtree().clone(result, basis=basis_tree)
725
except errors.NotLocalUrl:
726
# make a new one, this format always has to have one.
728
WorkingTreeFormat2().initialize(result)
729
except errors.NotLocalUrl:
730
# but we cannot do it for remote trees.
731
to_branch = result.open_branch()
732
WorkingTreeFormat2().stub_initialize_remote(to_branch.control_files)
735
def create_branch(self):
736
"""See BzrDir.create_branch."""
737
return self.open_branch()
739
def create_repository(self, shared=False):
740
"""See BzrDir.create_repository."""
742
raise errors.IncompatibleFormat('shared repository', self._format)
743
return self.open_repository()
745
def create_workingtree(self, revision_id=None):
746
"""See BzrDir.create_workingtree."""
747
# this looks buggy but is not -really-
748
# clone and sprout will have set the revision_id
749
# and that will have set it for us, its only
750
# specific uses of create_workingtree in isolation
751
# that can do wonky stuff here, and that only
752
# happens for creating checkouts, which cannot be
753
# done on this format anyway. So - acceptable wart.
754
result = self.open_workingtree()
755
if revision_id is not None:
756
if revision_id == _mod_revision.NULL_REVISION:
757
result.set_parent_ids([])
759
result.set_parent_ids([revision_id])
762
def destroy_workingtree(self):
763
"""See BzrDir.destroy_workingtree."""
764
raise errors.UnsupportedOperation(self.destroy_workingtree, self)
766
def destroy_workingtree_metadata(self):
767
"""See BzrDir.destroy_workingtree_metadata."""
768
raise errors.UnsupportedOperation(self.destroy_workingtree_metadata,
771
def get_branch_transport(self, branch_format):
772
"""See BzrDir.get_branch_transport()."""
773
if branch_format is None:
774
return self.transport
776
branch_format.get_format_string()
777
except NotImplementedError:
778
return self.transport
779
raise errors.IncompatibleFormat(branch_format, self._format)
781
def get_repository_transport(self, repository_format):
782
"""See BzrDir.get_repository_transport()."""
783
if repository_format is None:
784
return self.transport
786
repository_format.get_format_string()
787
except NotImplementedError:
788
return self.transport
789
raise errors.IncompatibleFormat(repository_format, self._format)
791
def get_workingtree_transport(self, workingtree_format):
792
"""See BzrDir.get_workingtree_transport()."""
793
if workingtree_format is None:
794
return self.transport
796
workingtree_format.get_format_string()
797
except NotImplementedError:
798
return self.transport
799
raise errors.IncompatibleFormat(workingtree_format, self._format)
801
def needs_format_conversion(self, format=None):
802
"""See BzrDir.needs_format_conversion()."""
803
# if the format is not the same as the system default,
804
# an upgrade is needed.
806
format = BzrDirFormat.get_default_format()
807
return not isinstance(self._format, format.__class__)
809
def open_branch(self, unsupported=False):
810
"""See BzrDir.open_branch."""
811
from bzrlib.branch import BzrBranchFormat4
812
format = BzrBranchFormat4()
813
self._check_supported(format, unsupported)
814
return format.open(self, _found=True)
816
def sprout(self, url, revision_id=None, basis=None, force_new_repo=False):
817
"""See BzrDir.sprout()."""
818
from bzrlib.workingtree import WorkingTreeFormat2
820
result = self._format._initialize_for_clone(url)
821
basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
823
self.open_repository().clone(result, revision_id=revision_id, basis=basis_repo)
824
except errors.NoRepositoryPresent:
827
self.open_branch().sprout(result, revision_id=revision_id)
828
except errors.NotBranchError:
830
# we always want a working tree
831
WorkingTreeFormat2().initialize(result)
835
class BzrDir4(BzrDirPreSplitOut):
836
"""A .bzr version 4 control object.
838
This is a deprecated format and may be removed after sept 2006.
841
def create_repository(self, shared=False):
842
"""See BzrDir.create_repository."""
843
return self._format.repository_format.initialize(self, shared)
845
def needs_format_conversion(self, format=None):
846
"""Format 4 dirs are always in need of conversion."""
849
def open_repository(self):
850
"""See BzrDir.open_repository."""
851
from bzrlib.repository import RepositoryFormat4
852
return RepositoryFormat4().open(self, _found=True)
855
class BzrDir5(BzrDirPreSplitOut):
856
"""A .bzr version 5 control object.
858
This is a deprecated format and may be removed after sept 2006.
861
def open_repository(self):
862
"""See BzrDir.open_repository."""
863
from bzrlib.repository import RepositoryFormat5
864
return RepositoryFormat5().open(self, _found=True)
866
def open_workingtree(self, _unsupported=False):
867
"""See BzrDir.create_workingtree."""
868
from bzrlib.workingtree import WorkingTreeFormat2
869
return WorkingTreeFormat2().open(self, _found=True)
872
class BzrDir6(BzrDirPreSplitOut):
873
"""A .bzr version 6 control object.
875
This is a deprecated format and may be removed after sept 2006.
878
def open_repository(self):
879
"""See BzrDir.open_repository."""
880
from bzrlib.repository import RepositoryFormat6
881
return RepositoryFormat6().open(self, _found=True)
883
def open_workingtree(self, _unsupported=False):
884
"""See BzrDir.create_workingtree."""
885
from bzrlib.workingtree import WorkingTreeFormat2
886
return WorkingTreeFormat2().open(self, _found=True)
889
class BzrDirMeta1(BzrDir):
890
"""A .bzr meta version 1 control object.
892
This is the first control object where the
893
individual aspects are really split out: there are separate repository,
894
workingtree and branch subdirectories and any subset of the three can be
895
present within a BzrDir.
898
def can_convert_format(self):
899
"""See BzrDir.can_convert_format()."""
902
def create_branch(self):
903
"""See BzrDir.create_branch."""
904
from bzrlib.branch import BranchFormat
905
return BranchFormat.get_default_format().initialize(self)
907
def create_repository(self, shared=False):
908
"""See BzrDir.create_repository."""
909
return self._format.repository_format.initialize(self, shared)
911
def create_workingtree(self, revision_id=None):
912
"""See BzrDir.create_workingtree."""
913
from bzrlib.workingtree import WorkingTreeFormat
914
return WorkingTreeFormat.get_default_format().initialize(self, revision_id)
916
def destroy_workingtree(self):
917
"""See BzrDir.destroy_workingtree."""
918
wt = self.open_workingtree()
919
repository = wt.branch.repository
920
empty = repository.revision_tree(bzrlib.revision.NULL_REVISION)
921
wt.revert([], old_tree=empty)
922
self.destroy_workingtree_metadata()
924
def destroy_workingtree_metadata(self):
925
self.transport.delete_tree('checkout')
927
def _get_mkdir_mode(self):
928
"""Figure out the mode to use when creating a bzrdir subdir."""
929
temp_control = lockable_files.LockableFiles(self.transport, '',
930
lockable_files.TransportLock)
931
return temp_control._dir_mode
933
def get_branch_transport(self, branch_format):
934
"""See BzrDir.get_branch_transport()."""
935
if branch_format is None:
936
return self.transport.clone('branch')
938
branch_format.get_format_string()
939
except NotImplementedError:
940
raise errors.IncompatibleFormat(branch_format, self._format)
942
self.transport.mkdir('branch', mode=self._get_mkdir_mode())
943
except errors.FileExists:
945
return self.transport.clone('branch')
947
def get_repository_transport(self, repository_format):
948
"""See BzrDir.get_repository_transport()."""
949
if repository_format is None:
950
return self.transport.clone('repository')
952
repository_format.get_format_string()
953
except NotImplementedError:
954
raise errors.IncompatibleFormat(repository_format, self._format)
956
self.transport.mkdir('repository', mode=self._get_mkdir_mode())
957
except errors.FileExists:
959
return self.transport.clone('repository')
961
def get_workingtree_transport(self, workingtree_format):
962
"""See BzrDir.get_workingtree_transport()."""
963
if workingtree_format is None:
964
return self.transport.clone('checkout')
966
workingtree_format.get_format_string()
967
except NotImplementedError:
968
raise errors.IncompatibleFormat(workingtree_format, self._format)
970
self.transport.mkdir('checkout', mode=self._get_mkdir_mode())
971
except errors.FileExists:
973
return self.transport.clone('checkout')
975
def needs_format_conversion(self, format=None):
976
"""See BzrDir.needs_format_conversion()."""
978
format = BzrDirFormat.get_default_format()
979
if not isinstance(self._format, format.__class__):
980
# it is not a meta dir format, conversion is needed.
982
# we might want to push this down to the repository?
984
if not isinstance(self.open_repository()._format,
985
format.repository_format.__class__):
986
# the repository needs an upgrade.
988
except errors.NoRepositoryPresent:
990
# currently there are no other possible conversions for meta1 formats.
993
def open_branch(self, unsupported=False):
994
"""See BzrDir.open_branch."""
995
from bzrlib.branch import BranchFormat
996
format = BranchFormat.find_format(self)
997
self._check_supported(format, unsupported)
998
return format.open(self, _found=True)
1000
def open_repository(self, unsupported=False):
1001
"""See BzrDir.open_repository."""
1002
from bzrlib.repository import RepositoryFormat
1003
format = RepositoryFormat.find_format(self)
1004
self._check_supported(format, unsupported)
1005
return format.open(self, _found=True)
1007
def open_workingtree(self, unsupported=False):
1008
"""See BzrDir.open_workingtree."""
1009
from bzrlib.workingtree import WorkingTreeFormat
1010
format = WorkingTreeFormat.find_format(self)
1011
self._check_supported(format, unsupported)
1012
return format.open(self, _found=True)
1015
class BzrDirFormat(object):
1016
"""An encapsulation of the initialization and open routines for a format.
1018
Formats provide three things:
1019
* An initialization routine,
1023
Formats are placed in an dict by their format string for reference
1024
during bzrdir opening. These should be subclasses of BzrDirFormat
1027
Once a format is deprecated, just deprecate the initialize and open
1028
methods on the format class. Do not deprecate the object, as the
1029
object will be created every system load.
1032
_default_format = None
1033
"""The default format used for new .bzr dirs."""
1036
"""The known formats."""
1038
_control_formats = []
1039
"""The registered control formats - .bzr, ....
1041
This is a list of BzrDirFormat objects.
1044
_lock_file_name = 'branch-lock'
1046
# _lock_class must be set in subclasses to the lock type, typ.
1047
# TransportLock or LockDir
1050
def find_format(klass, transport):
1051
"""Return the format present at transport."""
1052
for format in klass._control_formats:
1054
return format.probe_transport(transport)
1055
except errors.NotBranchError:
1056
# this format does not find a control dir here.
1058
raise errors.NotBranchError(path=transport.base)
1061
def probe_transport(klass, transport):
1062
"""Return the .bzrdir style transport present at URL."""
1064
format_string = transport.get(".bzr/branch-format").read()
1065
except errors.NoSuchFile:
1066
raise errors.NotBranchError(path=transport.base)
1069
return klass._formats[format_string]
1071
raise errors.UnknownFormatError(format=format_string)
1074
def get_default_format(klass):
1075
"""Return the current default format."""
1076
return klass._default_format
1078
def get_format_string(self):
1079
"""Return the ASCII format string that identifies this format."""
1080
raise NotImplementedError(self.get_format_string)
1082
def get_format_description(self):
1083
"""Return the short description for this format."""
1084
raise NotImplementedError(self.get_format_description)
1086
def get_converter(self, format=None):
1087
"""Return the converter to use to convert bzrdirs needing converts.
1089
This returns a bzrlib.bzrdir.Converter object.
1091
This should return the best upgrader to step this format towards the
1092
current default format. In the case of plugins we can/should provide
1093
some means for them to extend the range of returnable converters.
1095
:param format: Optional format to override the default format of the
1098
raise NotImplementedError(self.get_converter)
1100
def initialize(self, url):
1101
"""Create a bzr control dir at this url and return an opened copy.
1103
Subclasses should typically override initialize_on_transport
1104
instead of this method.
1106
return self.initialize_on_transport(get_transport(url))
1108
def initialize_on_transport(self, transport):
1109
"""Initialize a new bzrdir in the base directory of a Transport."""
1110
# Since we don't have a .bzr directory, inherit the
1111
# mode from the root directory
1112
temp_control = lockable_files.LockableFiles(transport,
1113
'', lockable_files.TransportLock)
1114
temp_control._transport.mkdir('.bzr',
1115
# FIXME: RBC 20060121 don't peek under
1117
mode=temp_control._dir_mode)
1118
file_mode = temp_control._file_mode
1120
mutter('created control directory in ' + transport.base)
1121
control = transport.clone('.bzr')
1122
utf8_files = [('README',
1123
"This is a Bazaar-NG control directory.\n"
1124
"Do not change any files in this directory.\n"),
1125
('branch-format', self.get_format_string()),
1127
# NB: no need to escape relative paths that are url safe.
1128
control_files = lockable_files.LockableFiles(control,
1129
self._lock_file_name, self._lock_class)
1130
control_files.create_lock()
1131
control_files.lock_write()
1133
for file, content in utf8_files:
1134
control_files.put_utf8(file, content)
1136
control_files.unlock()
1137
return self.open(transport, _found=True)
1139
def is_supported(self):
1140
"""Is this format supported?
1142
Supported formats must be initializable and openable.
1143
Unsupported formats may not support initialization or committing or
1144
some other features depending on the reason for not being supported.
1148
def same_model(self, target_format):
1149
return (self.repository_format.rich_root_data ==
1150
target_format.rich_root_data)
1153
def known_formats(klass):
1154
"""Return all the known formats.
1156
Concrete formats should override _known_formats.
1158
# There is double indirection here to make sure that control
1159
# formats used by more than one dir format will only be probed
1160
# once. This can otherwise be quite expensive for remote connections.
1162
for format in klass._control_formats:
1163
result.update(format._known_formats())
1167
def _known_formats(klass):
1168
"""Return the known format instances for this control format."""
1169
return set(klass._formats.values())
1171
def open(self, transport, _found=False):
1172
"""Return an instance of this format for the dir transport points at.
1174
_found is a private parameter, do not use it.
1177
found_format = BzrDirFormat.find_format(transport)
1178
if not isinstance(found_format, self.__class__):
1179
raise AssertionError("%s was asked to open %s, but it seems to need "
1181
% (self, transport, found_format))
1182
return self._open(transport)
1184
def _open(self, transport):
1185
"""Template method helper for opening BzrDirectories.
1187
This performs the actual open and any additional logic or parameter
1190
raise NotImplementedError(self._open)
1193
def register_format(klass, format):
1194
klass._formats[format.get_format_string()] = format
1197
def register_control_format(klass, format):
1198
"""Register a format that does not use '.bzrdir' for its control dir.
1200
TODO: This should be pulled up into a 'ControlDirFormat' base class
1201
which BzrDirFormat can inherit from, and renamed to register_format
1202
there. It has been done without that for now for simplicity of
1205
klass._control_formats.append(format)
1208
def set_default_format(klass, format):
1209
klass._default_format = format
1212
return self.get_format_string()[:-1]
1215
def unregister_format(klass, format):
1216
assert klass._formats[format.get_format_string()] is format
1217
del klass._formats[format.get_format_string()]
1220
def unregister_control_format(klass, format):
1221
klass._control_formats.remove(format)
1224
# register BzrDirFormat as a control format
1225
BzrDirFormat.register_control_format(BzrDirFormat)
1228
class BzrDirFormat4(BzrDirFormat):
1229
"""Bzr dir format 4.
1231
This format is a combined format for working tree, branch and repository.
1233
- Format 1 working trees [always]
1234
- Format 4 branches [always]
1235
- Format 4 repositories [always]
1237
This format is deprecated: it indexes texts using a text it which is
1238
removed in format 5; write support for this format has been removed.
1241
_lock_class = lockable_files.TransportLock
1243
def get_format_string(self):
1244
"""See BzrDirFormat.get_format_string()."""
1245
return "Bazaar-NG branch, format 0.0.4\n"
1247
def get_format_description(self):
1248
"""See BzrDirFormat.get_format_description()."""
1249
return "All-in-one format 4"
1251
def get_converter(self, format=None):
1252
"""See BzrDirFormat.get_converter()."""
1253
# there is one and only one upgrade path here.
1254
return ConvertBzrDir4To5()
1256
def initialize_on_transport(self, transport):
1257
"""Format 4 branches cannot be created."""
1258
raise errors.UninitializableFormat(self)
1260
def is_supported(self):
1261
"""Format 4 is not supported.
1263
It is not supported because the model changed from 4 to 5 and the
1264
conversion logic is expensive - so doing it on the fly was not
1269
def _open(self, transport):
1270
"""See BzrDirFormat._open."""
1271
return BzrDir4(transport, self)
1273
def __return_repository_format(self):
1274
"""Circular import protection."""
1275
from bzrlib.repository import RepositoryFormat4
1276
return RepositoryFormat4()
1277
repository_format = property(__return_repository_format)
1280
class BzrDirFormat5(BzrDirFormat):
1281
"""Bzr control format 5.
1283
This format is a combined format for working tree, branch and repository.
1285
- Format 2 working trees [always]
1286
- Format 4 branches [always]
1287
- Format 5 repositories [always]
1288
Unhashed stores in the repository.
1291
_lock_class = lockable_files.TransportLock
1293
def get_format_string(self):
1294
"""See BzrDirFormat.get_format_string()."""
1295
return "Bazaar-NG branch, format 5\n"
1297
def get_format_description(self):
1298
"""See BzrDirFormat.get_format_description()."""
1299
return "All-in-one format 5"
1301
def get_converter(self, format=None):
1302
"""See BzrDirFormat.get_converter()."""
1303
# there is one and only one upgrade path here.
1304
return ConvertBzrDir5To6()
1306
def _initialize_for_clone(self, url):
1307
return self.initialize_on_transport(get_transport(url), _cloning=True)
1309
def initialize_on_transport(self, transport, _cloning=False):
1310
"""Format 5 dirs always have working tree, branch and repository.
1312
Except when they are being cloned.
1314
from bzrlib.branch import BzrBranchFormat4
1315
from bzrlib.repository import RepositoryFormat5
1316
from bzrlib.workingtree import WorkingTreeFormat2
1317
result = (super(BzrDirFormat5, self).initialize_on_transport(transport))
1318
RepositoryFormat5().initialize(result, _internal=True)
1320
branch = BzrBranchFormat4().initialize(result)
1322
WorkingTreeFormat2().initialize(result)
1323
except errors.NotLocalUrl:
1324
# Even though we can't access the working tree, we need to
1325
# create its control files.
1326
WorkingTreeFormat2().stub_initialize_remote(branch.control_files)
1329
def _open(self, transport):
1330
"""See BzrDirFormat._open."""
1331
return BzrDir5(transport, self)
1333
def __return_repository_format(self):
1334
"""Circular import protection."""
1335
from bzrlib.repository import RepositoryFormat5
1336
return RepositoryFormat5()
1337
repository_format = property(__return_repository_format)
1340
class BzrDirFormat6(BzrDirFormat):
1341
"""Bzr control format 6.
1343
This format is a combined format for working tree, branch and repository.
1345
- Format 2 working trees [always]
1346
- Format 4 branches [always]
1347
- Format 6 repositories [always]
1350
_lock_class = lockable_files.TransportLock
1352
def get_format_string(self):
1353
"""See BzrDirFormat.get_format_string()."""
1354
return "Bazaar-NG branch, format 6\n"
1356
def get_format_description(self):
1357
"""See BzrDirFormat.get_format_description()."""
1358
return "All-in-one format 6"
1360
def get_converter(self, format=None):
1361
"""See BzrDirFormat.get_converter()."""
1362
# there is one and only one upgrade path here.
1363
return ConvertBzrDir6ToMeta()
1365
def _initialize_for_clone(self, url):
1366
return self.initialize_on_transport(get_transport(url), _cloning=True)
1368
def initialize_on_transport(self, transport, _cloning=False):
1369
"""Format 6 dirs always have working tree, branch and repository.
1371
Except when they are being cloned.
1373
from bzrlib.branch import BzrBranchFormat4
1374
from bzrlib.repository import RepositoryFormat6
1375
from bzrlib.workingtree import WorkingTreeFormat2
1376
result = super(BzrDirFormat6, self).initialize_on_transport(transport)
1377
RepositoryFormat6().initialize(result, _internal=True)
1379
branch = BzrBranchFormat4().initialize(result)
1381
WorkingTreeFormat2().initialize(result)
1382
except errors.NotLocalUrl:
1383
# Even though we can't access the working tree, we need to
1384
# create its control files.
1385
WorkingTreeFormat2().stub_initialize_remote(branch.control_files)
1388
def _open(self, transport):
1389
"""See BzrDirFormat._open."""
1390
return BzrDir6(transport, self)
1392
def __return_repository_format(self):
1393
"""Circular import protection."""
1394
from bzrlib.repository import RepositoryFormat6
1395
return RepositoryFormat6()
1396
repository_format = property(__return_repository_format)
1399
class BzrDirMetaFormat1(BzrDirFormat):
1400
"""Bzr meta control format 1
1402
This is the first format with split out working tree, branch and repository
1405
- Format 3 working trees [optional]
1406
- Format 5 branches [optional]
1407
- Format 7 repositories [optional]
1410
_lock_class = lockdir.LockDir
1412
def get_converter(self, format=None):
1413
"""See BzrDirFormat.get_converter()."""
1415
format = BzrDirFormat.get_default_format()
1416
if not isinstance(self, format.__class__):
1417
# converting away from metadir is not implemented
1418
raise NotImplementedError(self.get_converter)
1419
return ConvertMetaToMeta(format)
1421
def get_format_string(self):
1422
"""See BzrDirFormat.get_format_string()."""
1423
return "Bazaar-NG meta directory, format 1\n"
1425
def get_format_description(self):
1426
"""See BzrDirFormat.get_format_description()."""
1427
return "Meta directory format 1"
1429
def _open(self, transport):
1430
"""See BzrDirFormat._open."""
1431
return BzrDirMeta1(transport, self)
1433
def __return_repository_format(self):
1434
"""Circular import protection."""
1435
if getattr(self, '_repository_format', None):
1436
return self._repository_format
1437
from bzrlib.repository import RepositoryFormat
1438
return RepositoryFormat.get_default_format()
1440
def __set_repository_format(self, value):
1441
"""Allow changint the repository format for metadir formats."""
1442
self._repository_format = value
1444
repository_format = property(__return_repository_format, __set_repository_format)
1447
BzrDirFormat.register_format(BzrDirFormat4())
1448
BzrDirFormat.register_format(BzrDirFormat5())
1449
BzrDirFormat.register_format(BzrDirFormat6())
1450
__default_format = BzrDirMetaFormat1()
1451
BzrDirFormat.register_format(__default_format)
1452
BzrDirFormat.set_default_format(__default_format)
1455
class BzrDirTestProviderAdapter(object):
1456
"""A tool to generate a suite testing multiple bzrdir formats at once.
1458
This is done by copying the test once for each transport and injecting
1459
the transport_server, transport_readonly_server, and bzrdir_format
1460
classes into each copy. Each copy is also given a new id() to make it
1464
def __init__(self, transport_server, transport_readonly_server, formats):
1465
self._transport_server = transport_server
1466
self._transport_readonly_server = transport_readonly_server
1467
self._formats = formats
1469
def adapt(self, test):
1470
result = unittest.TestSuite()
1471
for format in self._formats:
1472
new_test = deepcopy(test)
1473
new_test.transport_server = self._transport_server
1474
new_test.transport_readonly_server = self._transport_readonly_server
1475
new_test.bzrdir_format = format
1476
def make_new_test_id():
1477
new_id = "%s(%s)" % (new_test.id(), format.__class__.__name__)
1478
return lambda: new_id
1479
new_test.id = make_new_test_id()
1480
result.addTest(new_test)
1484
class Converter(object):
1485
"""Converts a disk format object from one format to another."""
1487
def convert(self, to_convert, pb):
1488
"""Perform the conversion of to_convert, giving feedback via pb.
1490
:param to_convert: The disk object to convert.
1491
:param pb: a progress bar to use for progress information.
1494
def step(self, message):
1495
"""Update the pb by a step."""
1497
self.pb.update(message, self.count, self.total)
1500
class ConvertBzrDir4To5(Converter):
1501
"""Converts format 4 bzr dirs to format 5."""
1504
super(ConvertBzrDir4To5, self).__init__()
1505
self.converted_revs = set()
1506
self.absent_revisions = set()
1510
def convert(self, to_convert, pb):
1511
"""See Converter.convert()."""
1512
self.bzrdir = to_convert
1514
self.pb.note('starting upgrade from format 4 to 5')
1515
if isinstance(self.bzrdir.transport, LocalTransport):
1516
self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
1517
self._convert_to_weaves()
1518
return BzrDir.open(self.bzrdir.root_transport.base)
1520
def _convert_to_weaves(self):
1521
self.pb.note('note: upgrade may be faster if all store files are ungzipped first')
1524
stat = self.bzrdir.transport.stat('weaves')
1525
if not S_ISDIR(stat.st_mode):
1526
self.bzrdir.transport.delete('weaves')
1527
self.bzrdir.transport.mkdir('weaves')
1528
except errors.NoSuchFile:
1529
self.bzrdir.transport.mkdir('weaves')
1530
# deliberately not a WeaveFile as we want to build it up slowly.
1531
self.inv_weave = Weave('inventory')
1532
# holds in-memory weaves for all files
1533
self.text_weaves = {}
1534
self.bzrdir.transport.delete('branch-format')
1535
self.branch = self.bzrdir.open_branch()
1536
self._convert_working_inv()
1537
rev_history = self.branch.revision_history()
1538
# to_read is a stack holding the revisions we still need to process;
1539
# appending to it adds new highest-priority revisions
1540
self.known_revisions = set(rev_history)
1541
self.to_read = rev_history[-1:]
1543
rev_id = self.to_read.pop()
1544
if (rev_id not in self.revisions
1545
and rev_id not in self.absent_revisions):
1546
self._load_one_rev(rev_id)
1548
to_import = self._make_order()
1549
for i, rev_id in enumerate(to_import):
1550
self.pb.update('converting revision', i, len(to_import))
1551
self._convert_one_rev(rev_id)
1553
self._write_all_weaves()
1554
self._write_all_revs()
1555
self.pb.note('upgraded to weaves:')
1556
self.pb.note(' %6d revisions and inventories', len(self.revisions))
1557
self.pb.note(' %6d revisions not present', len(self.absent_revisions))
1558
self.pb.note(' %6d texts', self.text_count)
1559
self._cleanup_spare_files_after_format4()
1560
self.branch.control_files.put_utf8('branch-format', BzrDirFormat5().get_format_string())
1562
def _cleanup_spare_files_after_format4(self):
1563
# FIXME working tree upgrade foo.
1564
for n in 'merged-patches', 'pending-merged-patches':
1566
## assert os.path.getsize(p) == 0
1567
self.bzrdir.transport.delete(n)
1568
except errors.NoSuchFile:
1570
self.bzrdir.transport.delete_tree('inventory-store')
1571
self.bzrdir.transport.delete_tree('text-store')
1573
def _convert_working_inv(self):
1574
inv = xml4.serializer_v4.read_inventory(
1575
self.branch.control_files.get('inventory'))
1576
new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
1577
# FIXME inventory is a working tree change.
1578
self.branch.control_files.put('inventory', StringIO(new_inv_xml))
1580
def _write_all_weaves(self):
1581
controlweaves = WeaveStore(self.bzrdir.transport, prefixed=False)
1582
weave_transport = self.bzrdir.transport.clone('weaves')
1583
weaves = WeaveStore(weave_transport, prefixed=False)
1584
transaction = WriteTransaction()
1588
for file_id, file_weave in self.text_weaves.items():
1589
self.pb.update('writing weave', i, len(self.text_weaves))
1590
weaves._put_weave(file_id, file_weave, transaction)
1592
self.pb.update('inventory', 0, 1)
1593
controlweaves._put_weave('inventory', self.inv_weave, transaction)
1594
self.pb.update('inventory', 1, 1)
1598
def _write_all_revs(self):
1599
"""Write all revisions out in new form."""
1600
self.bzrdir.transport.delete_tree('revision-store')
1601
self.bzrdir.transport.mkdir('revision-store')
1602
revision_transport = self.bzrdir.transport.clone('revision-store')
1604
_revision_store = TextRevisionStore(TextStore(revision_transport,
1608
transaction = WriteTransaction()
1609
for i, rev_id in enumerate(self.converted_revs):
1610
self.pb.update('write revision', i, len(self.converted_revs))
1611
_revision_store.add_revision(self.revisions[rev_id], transaction)
1615
def _load_one_rev(self, rev_id):
1616
"""Load a revision object into memory.
1618
Any parents not either loaded or abandoned get queued to be
1620
self.pb.update('loading revision',
1621
len(self.revisions),
1622
len(self.known_revisions))
1623
if not self.branch.repository.has_revision(rev_id):
1625
self.pb.note('revision {%s} not present in branch; '
1626
'will be converted as a ghost',
1628
self.absent_revisions.add(rev_id)
1630
rev = self.branch.repository._revision_store.get_revision(rev_id,
1631
self.branch.repository.get_transaction())
1632
for parent_id in rev.parent_ids:
1633
self.known_revisions.add(parent_id)
1634
self.to_read.append(parent_id)
1635
self.revisions[rev_id] = rev
1637
def _load_old_inventory(self, rev_id):
1638
assert rev_id not in self.converted_revs
1639
old_inv_xml = self.branch.repository.inventory_store.get(rev_id).read()
1640
inv = xml4.serializer_v4.read_inventory_from_string(old_inv_xml)
1641
inv.revision_id = rev_id
1642
rev = self.revisions[rev_id]
1643
if rev.inventory_sha1:
1644
assert rev.inventory_sha1 == sha_string(old_inv_xml), \
1645
'inventory sha mismatch for {%s}' % rev_id
1648
def _load_updated_inventory(self, rev_id):
1649
assert rev_id in self.converted_revs
1650
inv_xml = self.inv_weave.get_text(rev_id)
1651
inv = xml5.serializer_v5.read_inventory_from_string(inv_xml)
1654
def _convert_one_rev(self, rev_id):
1655
"""Convert revision and all referenced objects to new format."""
1656
rev = self.revisions[rev_id]
1657
inv = self._load_old_inventory(rev_id)
1658
present_parents = [p for p in rev.parent_ids
1659
if p not in self.absent_revisions]
1660
self._convert_revision_contents(rev, inv, present_parents)
1661
self._store_new_weave(rev, inv, present_parents)
1662
self.converted_revs.add(rev_id)
1664
def _store_new_weave(self, rev, inv, present_parents):
1665
# the XML is now updated with text versions
1667
entries = inv.iter_entries()
1669
for path, ie in entries:
1670
assert getattr(ie, 'revision', None) is not None, \
1671
'no revision on {%s} in {%s}' % \
1672
(file_id, rev.revision_id)
1673
new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
1674
new_inv_sha1 = sha_string(new_inv_xml)
1675
self.inv_weave.add_lines(rev.revision_id,
1677
new_inv_xml.splitlines(True))
1678
rev.inventory_sha1 = new_inv_sha1
1680
def _convert_revision_contents(self, rev, inv, present_parents):
1681
"""Convert all the files within a revision.
1683
Also upgrade the inventory to refer to the text revision ids."""
1684
rev_id = rev.revision_id
1685
mutter('converting texts of revision {%s}',
1687
parent_invs = map(self._load_updated_inventory, present_parents)
1688
entries = inv.iter_entries()
1690
for path, ie in entries:
1691
self._convert_file_version(rev, ie, parent_invs)
1693
def _convert_file_version(self, rev, ie, parent_invs):
1694
"""Convert one version of one file.
1696
The file needs to be added into the weave if it is a merge
1697
of >=2 parents or if it's changed from its parent.
1699
file_id = ie.file_id
1700
rev_id = rev.revision_id
1701
w = self.text_weaves.get(file_id)
1704
self.text_weaves[file_id] = w
1705
text_changed = False
1706
previous_entries = ie.find_previous_heads(parent_invs,
1710
for old_revision in previous_entries:
1711
# if this fails, its a ghost ?
1712
assert old_revision in self.converted_revs, \
1713
"Revision {%s} not in converted_revs" % old_revision
1714
self.snapshot_ie(previous_entries, ie, w, rev_id)
1716
assert getattr(ie, 'revision', None) is not None
1718
def snapshot_ie(self, previous_revisions, ie, w, rev_id):
1719
# TODO: convert this logic, which is ~= snapshot to
1720
# a call to:. This needs the path figured out. rather than a work_tree
1721
# a v4 revision_tree can be given, or something that looks enough like
1722
# one to give the file content to the entry if it needs it.
1723
# and we need something that looks like a weave store for snapshot to
1725
#ie.snapshot(rev, PATH, previous_revisions, REVISION_TREE, InMemoryWeaveStore(self.text_weaves))
1726
if len(previous_revisions) == 1:
1727
previous_ie = previous_revisions.values()[0]
1728
if ie._unchanged(previous_ie):
1729
ie.revision = previous_ie.revision
1732
text = self.branch.repository.text_store.get(ie.text_id)
1733
file_lines = text.readlines()
1734
assert sha_strings(file_lines) == ie.text_sha1
1735
assert sum(map(len, file_lines)) == ie.text_size
1736
w.add_lines(rev_id, previous_revisions, file_lines)
1737
self.text_count += 1
1739
w.add_lines(rev_id, previous_revisions, [])
1740
ie.revision = rev_id
1742
def _make_order(self):
1743
"""Return a suitable order for importing revisions.
1745
The order must be such that an revision is imported after all
1746
its (present) parents.
1748
todo = set(self.revisions.keys())
1749
done = self.absent_revisions.copy()
1752
# scan through looking for a revision whose parents
1754
for rev_id in sorted(list(todo)):
1755
rev = self.revisions[rev_id]
1756
parent_ids = set(rev.parent_ids)
1757
if parent_ids.issubset(done):
1758
# can take this one now
1759
order.append(rev_id)
1765
class ConvertBzrDir5To6(Converter):
1766
"""Converts format 5 bzr dirs to format 6."""
1768
def convert(self, to_convert, pb):
1769
"""See Converter.convert()."""
1770
self.bzrdir = to_convert
1772
self.pb.note('starting upgrade from format 5 to 6')
1773
self._convert_to_prefixed()
1774
return BzrDir.open(self.bzrdir.root_transport.base)
1776
def _convert_to_prefixed(self):
1777
from bzrlib.store import TransportStore
1778
self.bzrdir.transport.delete('branch-format')
1779
for store_name in ["weaves", "revision-store"]:
1780
self.pb.note("adding prefixes to %s" % store_name)
1781
store_transport = self.bzrdir.transport.clone(store_name)
1782
store = TransportStore(store_transport, prefixed=True)
1783
for urlfilename in store_transport.list_dir('.'):
1784
filename = urlutils.unescape(urlfilename)
1785
if (filename.endswith(".weave") or
1786
filename.endswith(".gz") or
1787
filename.endswith(".sig")):
1788
file_id = os.path.splitext(filename)[0]
1791
prefix_dir = store.hash_prefix(file_id)
1792
# FIXME keep track of the dirs made RBC 20060121
1794
store_transport.move(filename, prefix_dir + '/' + filename)
1795
except errors.NoSuchFile: # catches missing dirs strangely enough
1796
store_transport.mkdir(prefix_dir)
1797
store_transport.move(filename, prefix_dir + '/' + filename)
1798
self.bzrdir._control_files.put_utf8('branch-format', BzrDirFormat6().get_format_string())
1801
class ConvertBzrDir6ToMeta(Converter):
1802
"""Converts format 6 bzr dirs to metadirs."""
1804
def convert(self, to_convert, pb):
1805
"""See Converter.convert()."""
1806
self.bzrdir = to_convert
1809
self.total = 20 # the steps we know about
1810
self.garbage_inventories = []
1812
self.pb.note('starting upgrade from format 6 to metadir')
1813
self.bzrdir._control_files.put_utf8('branch-format', "Converting to format 6")
1814
# its faster to move specific files around than to open and use the apis...
1815
# first off, nuke ancestry.weave, it was never used.
1817
self.step('Removing ancestry.weave')
1818
self.bzrdir.transport.delete('ancestry.weave')
1819
except errors.NoSuchFile:
1821
# find out whats there
1822
self.step('Finding branch files')
1823
last_revision = self.bzrdir.open_branch().last_revision()
1824
bzrcontents = self.bzrdir.transport.list_dir('.')
1825
for name in bzrcontents:
1826
if name.startswith('basis-inventory.'):
1827
self.garbage_inventories.append(name)
1828
# create new directories for repository, working tree and branch
1829
self.dir_mode = self.bzrdir._control_files._dir_mode
1830
self.file_mode = self.bzrdir._control_files._file_mode
1831
repository_names = [('inventory.weave', True),
1832
('revision-store', True),
1834
self.step('Upgrading repository ')
1835
self.bzrdir.transport.mkdir('repository', mode=self.dir_mode)
1836
self.make_lock('repository')
1837
# we hard code the formats here because we are converting into
1838
# the meta format. The meta format upgrader can take this to a
1839
# future format within each component.
1840
self.put_format('repository', bzrlib.repository.RepositoryFormat7())
1841
for entry in repository_names:
1842
self.move_entry('repository', entry)
1844
self.step('Upgrading branch ')
1845
self.bzrdir.transport.mkdir('branch', mode=self.dir_mode)
1846
self.make_lock('branch')
1847
self.put_format('branch', bzrlib.branch.BzrBranchFormat5())
1848
branch_files = [('revision-history', True),
1849
('branch-name', True),
1851
for entry in branch_files:
1852
self.move_entry('branch', entry)
1854
checkout_files = [('pending-merges', True),
1855
('inventory', True),
1856
('stat-cache', False)]
1857
# If a mandatory checkout file is not present, the branch does not have
1858
# a functional checkout. Do not create a checkout in the converted
1860
for name, mandatory in checkout_files:
1861
if mandatory and name not in bzrcontents:
1862
has_checkout = False
1866
if not has_checkout:
1867
self.pb.note('No working tree.')
1868
# If some checkout files are there, we may as well get rid of them.
1869
for name, mandatory in checkout_files:
1870
if name in bzrcontents:
1871
self.bzrdir.transport.delete(name)
1873
from bzrlib.workingtree import WorkingTreeFormat3
1874
self.step('Upgrading working tree')
1875
self.bzrdir.transport.mkdir('checkout', mode=self.dir_mode)
1876
self.make_lock('checkout')
1878
'checkout', WorkingTreeFormat3())
1879
self.bzrdir.transport.delete_multi(
1880
self.garbage_inventories, self.pb)
1881
for entry in checkout_files:
1882
self.move_entry('checkout', entry)
1883
if last_revision is not None:
1884
self.bzrdir._control_files.put_utf8(
1885
'checkout/last-revision', last_revision)
1886
self.bzrdir._control_files.put_utf8(
1887
'branch-format', BzrDirMetaFormat1().get_format_string())
1888
return BzrDir.open(self.bzrdir.root_transport.base)
1890
def make_lock(self, name):
1891
"""Make a lock for the new control dir name."""
1892
self.step('Make %s lock' % name)
1893
ld = lockdir.LockDir(self.bzrdir.transport,
1895
file_modebits=self.file_mode,
1896
dir_modebits=self.dir_mode)
1899
def move_entry(self, new_dir, entry):
1900
"""Move then entry name into new_dir."""
1902
mandatory = entry[1]
1903
self.step('Moving %s' % name)
1905
self.bzrdir.transport.move(name, '%s/%s' % (new_dir, name))
1906
except errors.NoSuchFile:
1910
def put_format(self, dirname, format):
1911
self.bzrdir._control_files.put_utf8('%s/format' % dirname, format.get_format_string())
1914
class ConvertMetaToMeta(Converter):
1915
"""Converts the components of metadirs."""
1917
def __init__(self, target_format):
1918
"""Create a metadir to metadir converter.
1920
:param target_format: The final metadir format that is desired.
1922
self.target_format = target_format
1924
def convert(self, to_convert, pb):
1925
"""See Converter.convert()."""
1926
self.bzrdir = to_convert
1930
self.step('checking repository format')
1932
repo = self.bzrdir.open_repository()
1933
except errors.NoRepositoryPresent:
1936
if not isinstance(repo._format, self.target_format.repository_format.__class__):
1937
from bzrlib.repository import CopyConverter
1938
self.pb.note('starting repository conversion')
1939
converter = CopyConverter(self.target_format.repository_format)
1940
converter.convert(repo, pb)
added
removed
bzrlib/bzrdir.py
