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 copy import deepcopy
32
from cStringIO import StringIO
34
from stat import S_ISDIR
35
from unittest import TestSuite
38
import bzrlib.errors as errors
39
from bzrlib.lockable_files import LockableFiles, TransportLock
40
from bzrlib.lockdir import LockDir
41
from bzrlib.osutils import (
48
import bzrlib.revision
49
from bzrlib.store.revision.text import TextRevisionStore
50
from bzrlib.store.text import TextStore
51
from bzrlib.store.versioned import WeaveStore
52
from bzrlib.trace import mutter
53
from bzrlib.transactions import WriteTransaction
54
from bzrlib.transport import get_transport
55
from bzrlib.transport.local import LocalTransport
56
import bzrlib.urlutils as urlutils
57
from bzrlib.weave import Weave
58
from bzrlib.xml4 import serializer_v4
63
"""A .bzr control diretory.
65
BzrDir instances let you create or open any of the things that can be
66
found within .bzr - checkouts, branches and repositories.
69
the transport which this bzr dir is rooted at (i.e. file:///.../.bzr/)
71
a transport connected to the directory this bzr was opened from.
75
"""Invoke break_lock on the first object in the bzrdir.
77
If there is a tree, the tree is opened and break_lock() called.
78
Otherwise, branch is tried, and finally repository.
81
thing_to_unlock = self.open_workingtree()
82
except (errors.NotLocalUrl, errors.NoWorkingTree):
84
thing_to_unlock = self.open_branch()
85
except errors.NotBranchError:
87
thing_to_unlock = self.open_repository()
88
except errors.NoRepositoryPresent:
90
thing_to_unlock.break_lock()
92
def can_convert_format(self):
93
"""Return true if this bzrdir is one whose format we can convert from."""
96
def check_conversion_target(self, target_format):
97
target_repo_format = target_format.repository_format
98
source_repo_format = self._format.repository_format
99
source_repo_format.check_conversion_target(target_repo_format)
102
def _check_supported(format, allow_unsupported):
103
"""Check whether format is a supported format.
105
If allow_unsupported is True, this is a no-op.
107
if not allow_unsupported and not format.is_supported():
108
# see open_downlevel to open legacy branches.
109
raise errors.UnsupportedFormatError(format=format)
111
def clone(self, url, revision_id=None, basis=None, force_new_repo=False):
112
"""Clone this bzrdir and its contents to url verbatim.
114
If urls last component does not exist, it will be created.
116
if revision_id is not None, then the clone operation may tune
117
itself to download less data.
118
:param force_new_repo: Do not use a shared repository for the target
119
even if one is available.
122
basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
123
result = self._format.initialize(url)
125
local_repo = self.find_repository()
126
except errors.NoRepositoryPresent:
129
# may need to copy content in
131
result_repo = local_repo.clone(
133
revision_id=revision_id,
135
result_repo.set_make_working_trees(local_repo.make_working_trees())
138
result_repo = result.find_repository()
139
# fetch content this dir needs.
141
# XXX FIXME RBC 20060214 need tests for this when the basis
143
result_repo.fetch(basis_repo, revision_id=revision_id)
144
result_repo.fetch(local_repo, revision_id=revision_id)
145
except errors.NoRepositoryPresent:
146
# needed to make one anyway.
147
result_repo = local_repo.clone(
149
revision_id=revision_id,
151
result_repo.set_make_working_trees(local_repo.make_working_trees())
152
# 1 if there is a branch present
153
# make sure its content is available in the target repository
156
self.open_branch().clone(result, revision_id=revision_id)
157
except errors.NotBranchError:
160
self.open_workingtree().clone(result, basis=basis_tree)
161
except (errors.NoWorkingTree, errors.NotLocalUrl):
165
def _get_basis_components(self, basis):
166
"""Retrieve the basis components that are available at basis."""
168
return None, None, None
170
basis_tree = basis.open_workingtree()
171
basis_branch = basis_tree.branch
172
basis_repo = basis_branch.repository
173
except (errors.NoWorkingTree, errors.NotLocalUrl):
176
basis_branch = basis.open_branch()
177
basis_repo = basis_branch.repository
178
except errors.NotBranchError:
181
basis_repo = basis.open_repository()
182
except errors.NoRepositoryPresent:
184
return basis_repo, basis_branch, basis_tree
186
# TODO: This should be given a Transport, and should chdir up; otherwise
187
# this will open a new connection.
188
def _make_tail(self, url):
189
head, tail = urlutils.split(url)
190
if tail and tail != '.':
191
t = bzrlib.transport.get_transport(head)
194
except errors.FileExists:
197
# TODO: Should take a Transport
199
def create(cls, base):
200
"""Create a new BzrDir at the url 'base'.
202
This will call the current default formats initialize with base
203
as the only parameter.
205
If you need a specific format, consider creating an instance
206
of that and calling initialize().
208
if cls is not BzrDir:
209
raise AssertionError("BzrDir.create always creates the default format, "
210
"not one of %r" % cls)
211
head, tail = urlutils.split(base)
212
if tail and tail != '.':
213
t = bzrlib.transport.get_transport(head)
216
except errors.FileExists:
218
return BzrDirFormat.get_default_format().initialize(safe_unicode(base))
220
def create_branch(self):
221
"""Create a branch in this BzrDir.
223
The bzrdirs format will control what branch format is created.
224
For more control see BranchFormatXX.create(a_bzrdir).
226
raise NotImplementedError(self.create_branch)
229
def create_branch_and_repo(base, force_new_repo=False):
230
"""Create a new BzrDir, Branch and Repository at the url 'base'.
232
This will use the current default BzrDirFormat, and use whatever
233
repository format that that uses via bzrdir.create_branch and
234
create_repository. If a shared repository is available that is used
237
The created Branch object is returned.
239
:param base: The URL to create the branch at.
240
:param force_new_repo: If True a new repository is always created.
242
bzrdir = BzrDir.create(base)
243
bzrdir._find_or_create_repository(force_new_repo)
244
return bzrdir.create_branch()
246
def _find_or_create_repository(self, force_new_repo):
247
"""Create a new repository if needed, returning the repository."""
249
return self.create_repository()
251
return self.find_repository()
252
except errors.NoRepositoryPresent:
253
return self.create_repository()
256
def create_branch_convenience(base, force_new_repo=False,
257
force_new_tree=None, format=None):
258
"""Create a new BzrDir, Branch and Repository at the url 'base'.
260
This is a convenience function - it will use an existing repository
261
if possible, can be told explicitly whether to create a working tree or
264
This will use the current default BzrDirFormat, and use whatever
265
repository format that that uses via bzrdir.create_branch and
266
create_repository. If a shared repository is available that is used
267
preferentially. Whatever repository is used, its tree creation policy
270
The created Branch object is returned.
271
If a working tree cannot be made due to base not being a file:// url,
272
no error is raised unless force_new_tree is True, in which case no
273
data is created on disk and NotLocalUrl is raised.
275
:param base: The URL to create the branch at.
276
:param force_new_repo: If True a new repository is always created.
277
:param force_new_tree: If True or False force creation of a tree or
278
prevent such creation respectively.
279
:param format: Override for the for the bzrdir format to create
282
# check for non local urls
283
t = get_transport(safe_unicode(base))
284
if not isinstance(t, LocalTransport):
285
raise errors.NotLocalUrl(base)
287
bzrdir = BzrDir.create(base)
289
bzrdir = format.initialize(base)
290
repo = bzrdir._find_or_create_repository(force_new_repo)
291
result = bzrdir.create_branch()
292
if force_new_tree or (repo.make_working_trees() and
293
force_new_tree is None):
295
bzrdir.create_workingtree()
296
except errors.NotLocalUrl:
301
def create_repository(base, shared=False):
302
"""Create a new BzrDir and Repository at the url 'base'.
304
This will use the current default BzrDirFormat, and use whatever
305
repository format that that uses for bzrdirformat.create_repository.
307
:param shared: Create a shared repository rather than a standalone
309
The Repository object is returned.
311
This must be overridden as an instance method in child classes, where
312
it should take no parameters and construct whatever repository format
313
that child class desires.
315
bzrdir = BzrDir.create(base)
316
return bzrdir.create_repository(shared)
319
def create_standalone_workingtree(base):
320
"""Create a new BzrDir, WorkingTree, Branch and Repository at 'base'.
322
'base' must be a local path or a file:// url.
324
This will use the current default BzrDirFormat, and use whatever
325
repository format that that uses for bzrdirformat.create_workingtree,
326
create_branch and create_repository.
328
:return: The WorkingTree object.
330
t = get_transport(safe_unicode(base))
331
if not isinstance(t, LocalTransport):
332
raise errors.NotLocalUrl(base)
333
bzrdir = BzrDir.create_branch_and_repo(safe_unicode(base),
334
force_new_repo=True).bzrdir
335
return bzrdir.create_workingtree()
337
def create_workingtree(self, revision_id=None):
338
"""Create a working tree at this BzrDir.
340
revision_id: create it as of this revision id.
342
raise NotImplementedError(self.create_workingtree)
344
def destroy_workingtree(self):
345
"""Destroy the working tree at this BzrDir.
347
Formats that do not support this may raise UnsupportedOperation.
349
raise NotImplementedError(self.destroy_workingtree)
351
def destroy_workingtree_metadata(self):
352
"""Destroy the control files for the working tree at this BzrDir.
354
The contents of working tree files are not affected.
355
Formats that do not support this may raise UnsupportedOperation.
357
raise NotImplementedError(self.destroy_workingtree_metadata)
359
def find_repository(self):
360
"""Find the repository that should be used for a_bzrdir.
362
This does not require a branch as we use it to find the repo for
363
new branches as well as to hook existing branches up to their
367
return self.open_repository()
368
except errors.NoRepositoryPresent:
370
next_transport = self.root_transport.clone('..')
372
# find the next containing bzrdir
374
found_bzrdir = BzrDir.open_containing_from_transport(
376
except errors.NotBranchError:
378
raise errors.NoRepositoryPresent(self)
379
# does it have a repository ?
381
repository = found_bzrdir.open_repository()
382
except errors.NoRepositoryPresent:
383
next_transport = found_bzrdir.root_transport.clone('..')
384
if (found_bzrdir.root_transport.base == next_transport.base):
385
# top of the file system
389
if ((found_bzrdir.root_transport.base ==
390
self.root_transport.base) or repository.is_shared()):
393
raise errors.NoRepositoryPresent(self)
394
raise errors.NoRepositoryPresent(self)
396
def get_branch_transport(self, branch_format):
397
"""Get the transport for use by branch format in this BzrDir.
399
Note that bzr dirs that do not support format strings will raise
400
IncompatibleFormat if the branch format they are given has
401
a format string, and vice versa.
403
If branch_format is None, the transport is returned with no
404
checking. if it is not None, then the returned transport is
405
guaranteed to point to an existing directory ready for use.
407
raise NotImplementedError(self.get_branch_transport)
409
def get_repository_transport(self, repository_format):
410
"""Get the transport for use by repository format in this BzrDir.
412
Note that bzr dirs that do not support format strings will raise
413
IncompatibleFormat if the repository format they are given has
414
a format string, and vice versa.
416
If repository_format is None, the transport is returned with no
417
checking. if it is not None, then the returned transport is
418
guaranteed to point to an existing directory ready for use.
420
raise NotImplementedError(self.get_repository_transport)
422
def get_workingtree_transport(self, tree_format):
423
"""Get the transport for use by workingtree format in this BzrDir.
425
Note that bzr dirs that do not support format strings will raise
426
IncompatibleFormat if the workingtree format they are given has
427
a format string, and vice versa.
429
If workingtree_format is None, the transport is returned with no
430
checking. if it is not None, then the returned transport is
431
guaranteed to point to an existing directory ready for use.
433
raise NotImplementedError(self.get_workingtree_transport)
435
def __init__(self, _transport, _format):
436
"""Initialize a Bzr control dir object.
438
Only really common logic should reside here, concrete classes should be
439
made with varying behaviours.
441
:param _format: the format that is creating this BzrDir instance.
442
:param _transport: the transport this dir is based at.
444
self._format = _format
445
self.transport = _transport.clone('.bzr')
446
self.root_transport = _transport
448
def is_control_filename(self, filename):
449
"""True if filename is the name of a path which is reserved for bzrdir's.
451
:param filename: A filename within the root transport of this bzrdir.
453
This is true IF and ONLY IF the filename is part of the namespace reserved
454
for bzr control dirs. Currently this is the '.bzr' directory in the root
455
of the root_transport. it is expected that plugins will need to extend
456
this in the future - for instance to make bzr talk with svn working
459
# this might be better on the BzrDirFormat class because it refers to
460
# all the possible bzrdir disk formats.
461
# This method is tested via the workingtree is_control_filename tests-
462
# it was extracted from WorkingTree.is_control_filename. If the methods
463
# contract is extended beyond the current trivial implementation please
464
# add new tests for it to the appropriate place.
465
return filename == '.bzr' or filename.startswith('.bzr/')
467
def needs_format_conversion(self, format=None):
468
"""Return true if this bzrdir needs convert_format run on it.
470
For instance, if the repository format is out of date but the
471
branch and working tree are not, this should return True.
473
:param format: Optional parameter indicating a specific desired
474
format we plan to arrive at.
476
raise NotImplementedError(self.needs_format_conversion)
479
def open_unsupported(base):
480
"""Open a branch which is not supported."""
481
return BzrDir.open(base, _unsupported=True)
484
def open(base, _unsupported=False):
485
"""Open an existing bzrdir, rooted at 'base' (url)
487
_unsupported is a private parameter to the BzrDir class.
489
t = get_transport(base)
490
return BzrDir.open_from_transport(t, _unsupported=_unsupported)
493
def open_from_transport(transport, _unsupported=False):
494
"""Open a bzrdir within a particular directory.
496
:param transport: Transport containing the bzrdir.
497
:param _unsupported: private.
499
format = BzrDirFormat.find_format(transport)
500
BzrDir._check_supported(format, _unsupported)
501
return format.open(transport, _found=True)
503
def open_branch(self, unsupported=False):
504
"""Open the branch object at this BzrDir if one is present.
506
If unsupported is True, then no longer supported branch formats can
509
TODO: static convenience version of this?
511
raise NotImplementedError(self.open_branch)
514
def open_containing(url):
515
"""Open an existing branch which contains url.
517
:param url: url to search from.
518
See open_containing_from_transport for more detail.
520
return BzrDir.open_containing_from_transport(get_transport(url))
523
def open_containing_from_transport(a_transport):
524
"""Open an existing branch which contains a_transport.base
526
This probes for a branch at a_transport, and searches upwards from there.
528
Basically we keep looking up until we find the control directory or
529
run into the root. If there isn't one, raises NotBranchError.
530
If there is one and it is either an unrecognised format or an unsupported
531
format, UnknownFormatError or UnsupportedFormatError are raised.
532
If there is one, it is returned, along with the unused portion of url.
534
:return: The BzrDir that contains the path, and a Unicode path
535
for the rest of the URL.
537
# this gets the normalised url back. I.e. '.' -> the full path.
538
url = a_transport.base
541
result = BzrDir.open_from_transport(a_transport)
542
return result, urlutils.unescape(a_transport.relpath(url))
543
except errors.NotBranchError, e:
545
new_t = a_transport.clone('..')
546
if new_t.base == a_transport.base:
547
# reached the root, whatever that may be
548
raise errors.NotBranchError(path=url)
551
def open_repository(self, _unsupported=False):
552
"""Open the repository object at this BzrDir if one is present.
554
This will not follow the Branch object pointer - its strictly a direct
555
open facility. Most client code should use open_branch().repository to
558
_unsupported is a private parameter, not part of the api.
559
TODO: static convenience version of this?
561
raise NotImplementedError(self.open_repository)
563
def open_workingtree(self, _unsupported=False):
564
"""Open the workingtree object at this BzrDir if one is present.
566
TODO: static convenience version of this?
568
raise NotImplementedError(self.open_workingtree)
570
def has_branch(self):
571
"""Tell if this bzrdir contains a branch.
573
Note: if you're going to open the branch, you should just go ahead
574
and try, and not ask permission first. (This method just opens the
575
branch and discards it, and that's somewhat expensive.)
580
except errors.NotBranchError:
583
def has_workingtree(self):
584
"""Tell if this bzrdir contains a working tree.
586
This will still raise an exception if the bzrdir has a workingtree that
587
is remote & inaccessible.
589
Note: if you're going to open the working tree, you should just go ahead
590
and try, and not ask permission first. (This method just opens the
591
workingtree and discards it, and that's somewhat expensive.)
594
self.open_workingtree()
596
except errors.NoWorkingTree:
599
def cloning_metadir(self, basis=None):
600
"""Produce a metadir suitable for cloning with"""
601
def related_repository(bzrdir):
603
branch = bzrdir.open_branch()
604
return branch.repository
605
except errors.NotBranchError:
607
return bzrdir.open_repository()
608
result_format = self._format.__class__()
611
source_repository = related_repository(self)
612
except errors.NoRepositoryPresent:
615
source_repository = related_repository(self)
616
result_format.repository_format = source_repository._format
617
except errors.NoRepositoryPresent:
621
def sprout(self, url, revision_id=None, basis=None, force_new_repo=False):
622
"""Create a copy of this bzrdir prepared for use as a new line of
625
If urls last component does not exist, it will be created.
627
Attributes related to the identity of the source branch like
628
branch nickname will be cleaned, a working tree is created
629
whether one existed before or not; and a local branch is always
632
if revision_id is not None, then the clone operation may tune
633
itself to download less data.
636
cloning_format = self.cloning_metadir(basis)
637
result = cloning_format.initialize(url)
638
basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
640
source_branch = self.open_branch()
641
source_repository = source_branch.repository
642
except errors.NotBranchError:
645
source_repository = self.open_repository()
646
except errors.NoRepositoryPresent:
647
# copy the entire basis one if there is one
648
# but there is no repository.
649
source_repository = basis_repo
654
result_repo = result.find_repository()
655
except errors.NoRepositoryPresent:
657
if source_repository is None and result_repo is not None:
659
elif source_repository is None and result_repo is None:
660
# no repo available, make a new one
661
result.create_repository()
662
elif source_repository is not None and result_repo is None:
663
# have source, and want to make a new target repo
664
# we don't clone the repo because that preserves attributes
665
# like is_shared(), and we have not yet implemented a
666
# repository sprout().
667
result_repo = result.create_repository()
668
if result_repo is not None:
669
# fetch needed content into target.
671
# XXX FIXME RBC 20060214 need tests for this when the basis
673
result_repo.fetch(basis_repo, revision_id=revision_id)
674
if source_repository is not None:
675
result_repo.fetch(source_repository, revision_id=revision_id)
676
if source_branch is not None:
677
source_branch.sprout(result, revision_id=revision_id)
679
result.create_branch()
680
# TODO: jam 20060426 we probably need a test in here in the
681
# case that the newly sprouted branch is a remote one
682
if result_repo is None or result_repo.make_working_trees():
683
result.create_workingtree()
687
class BzrDirPreSplitOut(BzrDir):
688
"""A common class for the all-in-one formats."""
690
def __init__(self, _transport, _format):
691
"""See BzrDir.__init__."""
692
super(BzrDirPreSplitOut, self).__init__(_transport, _format)
693
assert self._format._lock_class == TransportLock
694
assert self._format._lock_file_name == 'branch-lock'
695
self._control_files = LockableFiles(self.get_branch_transport(None),
696
self._format._lock_file_name,
697
self._format._lock_class)
699
def break_lock(self):
700
"""Pre-splitout bzrdirs do not suffer from stale locks."""
701
raise NotImplementedError(self.break_lock)
703
def clone(self, url, revision_id=None, basis=None, force_new_repo=False):
704
"""See BzrDir.clone()."""
705
from bzrlib.workingtree import WorkingTreeFormat2
707
result = self._format._initialize_for_clone(url)
708
basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
709
self.open_repository().clone(result, revision_id=revision_id, basis=basis_repo)
710
from_branch = self.open_branch()
711
from_branch.clone(result, revision_id=revision_id)
713
self.open_workingtree().clone(result, basis=basis_tree)
714
except errors.NotLocalUrl:
715
# make a new one, this format always has to have one.
717
WorkingTreeFormat2().initialize(result)
718
except errors.NotLocalUrl:
719
# but we cannot do it for remote trees.
720
to_branch = result.open_branch()
721
WorkingTreeFormat2().stub_initialize_remote(to_branch.control_files)
724
def create_branch(self):
725
"""See BzrDir.create_branch."""
726
return self.open_branch()
728
def create_repository(self, shared=False):
729
"""See BzrDir.create_repository."""
731
raise errors.IncompatibleFormat('shared repository', self._format)
732
return self.open_repository()
734
def create_workingtree(self, revision_id=None):
735
"""See BzrDir.create_workingtree."""
736
# this looks buggy but is not -really-
737
# clone and sprout will have set the revision_id
738
# and that will have set it for us, its only
739
# specific uses of create_workingtree in isolation
740
# that can do wonky stuff here, and that only
741
# happens for creating checkouts, which cannot be
742
# done on this format anyway. So - acceptable wart.
743
result = self.open_workingtree()
744
if revision_id is not None:
745
if revision_id == bzrlib.revision.NULL_REVISION:
746
result.set_parent_ids([])
748
result.set_parent_ids([revision_id])
751
def destroy_workingtree(self):
752
"""See BzrDir.destroy_workingtree."""
753
raise errors.UnsupportedOperation(self.destroy_workingtree, self)
755
def destroy_workingtree_metadata(self):
756
"""See BzrDir.destroy_workingtree_metadata."""
757
raise errors.UnsupportedOperation(self.destroy_workingtree_metadata,
760
def get_branch_transport(self, branch_format):
761
"""See BzrDir.get_branch_transport()."""
762
if branch_format is None:
763
return self.transport
765
branch_format.get_format_string()
766
except NotImplementedError:
767
return self.transport
768
raise errors.IncompatibleFormat(branch_format, self._format)
770
def get_repository_transport(self, repository_format):
771
"""See BzrDir.get_repository_transport()."""
772
if repository_format is None:
773
return self.transport
775
repository_format.get_format_string()
776
except NotImplementedError:
777
return self.transport
778
raise errors.IncompatibleFormat(repository_format, self._format)
780
def get_workingtree_transport(self, workingtree_format):
781
"""See BzrDir.get_workingtree_transport()."""
782
if workingtree_format is None:
783
return self.transport
785
workingtree_format.get_format_string()
786
except NotImplementedError:
787
return self.transport
788
raise errors.IncompatibleFormat(workingtree_format, self._format)
790
def needs_format_conversion(self, format=None):
791
"""See BzrDir.needs_format_conversion()."""
792
# if the format is not the same as the system default,
793
# an upgrade is needed.
795
format = BzrDirFormat.get_default_format()
796
return not isinstance(self._format, format.__class__)
798
def open_branch(self, unsupported=False):
799
"""See BzrDir.open_branch."""
800
from bzrlib.branch import BzrBranchFormat4
801
format = BzrBranchFormat4()
802
self._check_supported(format, unsupported)
803
return format.open(self, _found=True)
805
def sprout(self, url, revision_id=None, basis=None, force_new_repo=False):
806
"""See BzrDir.sprout()."""
807
from bzrlib.workingtree import WorkingTreeFormat2
809
result = self._format._initialize_for_clone(url)
810
basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
812
self.open_repository().clone(result, revision_id=revision_id, basis=basis_repo)
813
except errors.NoRepositoryPresent:
816
self.open_branch().sprout(result, revision_id=revision_id)
817
except errors.NotBranchError:
819
# we always want a working tree
820
WorkingTreeFormat2().initialize(result)
824
class BzrDir4(BzrDirPreSplitOut):
825
"""A .bzr version 4 control object.
827
This is a deprecated format and may be removed after sept 2006.
830
def create_repository(self, shared=False):
831
"""See BzrDir.create_repository."""
832
return self._format.repository_format.initialize(self, shared)
834
def needs_format_conversion(self, format=None):
835
"""Format 4 dirs are always in need of conversion."""
838
def open_repository(self):
839
"""See BzrDir.open_repository."""
840
from bzrlib.repository import RepositoryFormat4
841
return RepositoryFormat4().open(self, _found=True)
844
class BzrDir5(BzrDirPreSplitOut):
845
"""A .bzr version 5 control object.
847
This is a deprecated format and may be removed after sept 2006.
850
def open_repository(self):
851
"""See BzrDir.open_repository."""
852
from bzrlib.repository import RepositoryFormat5
853
return RepositoryFormat5().open(self, _found=True)
855
def open_workingtree(self, _unsupported=False):
856
"""See BzrDir.create_workingtree."""
857
from bzrlib.workingtree import WorkingTreeFormat2
858
return WorkingTreeFormat2().open(self, _found=True)
861
class BzrDir6(BzrDirPreSplitOut):
862
"""A .bzr version 6 control object.
864
This is a deprecated format and may be removed after sept 2006.
867
def open_repository(self):
868
"""See BzrDir.open_repository."""
869
from bzrlib.repository import RepositoryFormat6
870
return RepositoryFormat6().open(self, _found=True)
872
def open_workingtree(self, _unsupported=False):
873
"""See BzrDir.create_workingtree."""
874
from bzrlib.workingtree import WorkingTreeFormat2
875
return WorkingTreeFormat2().open(self, _found=True)
878
class BzrDirMeta1(BzrDir):
879
"""A .bzr meta version 1 control object.
881
This is the first control object where the
882
individual aspects are really split out: there are separate repository,
883
workingtree and branch subdirectories and any subset of the three can be
884
present within a BzrDir.
887
def can_convert_format(self):
888
"""See BzrDir.can_convert_format()."""
891
def create_branch(self):
892
"""See BzrDir.create_branch."""
893
from bzrlib.branch import BranchFormat
894
return BranchFormat.get_default_format().initialize(self)
896
def create_repository(self, shared=False):
897
"""See BzrDir.create_repository."""
898
return self._format.repository_format.initialize(self, shared)
900
def create_workingtree(self, revision_id=None):
901
"""See BzrDir.create_workingtree."""
902
from bzrlib.workingtree import WorkingTreeFormat
903
return WorkingTreeFormat.get_default_format().initialize(self, revision_id)
905
def destroy_workingtree(self):
906
"""See BzrDir.destroy_workingtree."""
907
wt = self.open_workingtree()
908
repository = wt.branch.repository
909
empty = repository.revision_tree(bzrlib.revision.NULL_REVISION)
910
wt.revert([], old_tree=empty)
911
self.destroy_workingtree_metadata()
913
def destroy_workingtree_metadata(self):
914
self.transport.delete_tree('checkout')
916
def _get_mkdir_mode(self):
917
"""Figure out the mode to use when creating a bzrdir subdir."""
918
temp_control = LockableFiles(self.transport, '', TransportLock)
919
return temp_control._dir_mode
921
def get_branch_transport(self, branch_format):
922
"""See BzrDir.get_branch_transport()."""
923
if branch_format is None:
924
return self.transport.clone('branch')
926
branch_format.get_format_string()
927
except NotImplementedError:
928
raise errors.IncompatibleFormat(branch_format, self._format)
930
self.transport.mkdir('branch', mode=self._get_mkdir_mode())
931
except errors.FileExists:
933
return self.transport.clone('branch')
935
def get_repository_transport(self, repository_format):
936
"""See BzrDir.get_repository_transport()."""
937
if repository_format is None:
938
return self.transport.clone('repository')
940
repository_format.get_format_string()
941
except NotImplementedError:
942
raise errors.IncompatibleFormat(repository_format, self._format)
944
self.transport.mkdir('repository', mode=self._get_mkdir_mode())
945
except errors.FileExists:
947
return self.transport.clone('repository')
949
def get_workingtree_transport(self, workingtree_format):
950
"""See BzrDir.get_workingtree_transport()."""
951
if workingtree_format is None:
952
return self.transport.clone('checkout')
954
workingtree_format.get_format_string()
955
except NotImplementedError:
956
raise errors.IncompatibleFormat(workingtree_format, self._format)
958
self.transport.mkdir('checkout', mode=self._get_mkdir_mode())
959
except errors.FileExists:
961
return self.transport.clone('checkout')
963
def needs_format_conversion(self, format=None):
964
"""See BzrDir.needs_format_conversion()."""
966
format = BzrDirFormat.get_default_format()
967
if not isinstance(self._format, format.__class__):
968
# it is not a meta dir format, conversion is needed.
970
# we might want to push this down to the repository?
972
if not isinstance(self.open_repository()._format,
973
format.repository_format.__class__):
974
# the repository needs an upgrade.
976
except errors.NoRepositoryPresent:
978
# currently there are no other possible conversions for meta1 formats.
981
def open_branch(self, unsupported=False):
982
"""See BzrDir.open_branch."""
983
from bzrlib.branch import BranchFormat
984
format = BranchFormat.find_format(self)
985
self._check_supported(format, unsupported)
986
return format.open(self, _found=True)
988
def open_repository(self, unsupported=False):
989
"""See BzrDir.open_repository."""
990
from bzrlib.repository import RepositoryFormat
991
format = RepositoryFormat.find_format(self)
992
self._check_supported(format, unsupported)
993
return format.open(self, _found=True)
995
def open_workingtree(self, unsupported=False):
996
"""See BzrDir.open_workingtree."""
997
from bzrlib.workingtree import WorkingTreeFormat
998
format = WorkingTreeFormat.find_format(self)
999
self._check_supported(format, unsupported)
1000
return format.open(self, _found=True)
1003
class BzrDirFormat(object):
1004
"""An encapsulation of the initialization and open routines for a format.
1006
Formats provide three things:
1007
* An initialization routine,
1011
Formats are placed in an dict by their format string for reference
1012
during bzrdir opening. These should be subclasses of BzrDirFormat
1015
Once a format is deprecated, just deprecate the initialize and open
1016
methods on the format class. Do not deprecate the object, as the
1017
object will be created every system load.
1020
_default_format = None
1021
"""The default format used for new .bzr dirs."""
1024
"""The known formats."""
1026
_control_formats = []
1027
"""The registered control formats - .bzr, ....
1029
This is a list of BzrDirFormat objects.
1032
_lock_file_name = 'branch-lock'
1034
# _lock_class must be set in subclasses to the lock type, typ.
1035
# TransportLock or LockDir
1038
def find_format(klass, transport):
1039
"""Return the format present at transport."""
1040
for format in klass._control_formats:
1042
return format.probe_transport(transport)
1043
except errors.NotBranchError:
1044
# this format does not find a control dir here.
1046
raise errors.NotBranchError(path=transport.base)
1049
def probe_transport(klass, transport):
1050
"""Return the .bzrdir style transport present at URL."""
1052
format_string = transport.get(".bzr/branch-format").read()
1053
except errors.NoSuchFile:
1054
raise errors.NotBranchError(path=transport.base)
1057
return klass._formats[format_string]
1059
raise errors.UnknownFormatError(format=format_string)
1062
def get_default_format(klass):
1063
"""Return the current default format."""
1064
return klass._default_format
1066
def get_format_string(self):
1067
"""Return the ASCII format string that identifies this format."""
1068
raise NotImplementedError(self.get_format_string)
1070
def get_format_description(self):
1071
"""Return the short description for this format."""
1072
raise NotImplementedError(self.get_format_description)
1074
def get_converter(self, format=None):
1075
"""Return the converter to use to convert bzrdirs needing converts.
1077
This returns a bzrlib.bzrdir.Converter object.
1079
This should return the best upgrader to step this format towards the
1080
current default format. In the case of plugins we can/should provide
1081
some means for them to extend the range of returnable converters.
1083
:param format: Optional format to override the default format of the
1086
raise NotImplementedError(self.get_converter)
1088
def initialize(self, url):
1089
"""Create a bzr control dir at this url and return an opened copy.
1091
Subclasses should typically override initialize_on_transport
1092
instead of this method.
1094
return self.initialize_on_transport(get_transport(url))
1096
def initialize_on_transport(self, transport):
1097
"""Initialize a new bzrdir in the base directory of a Transport."""
1098
# Since we don't have a .bzr directory, inherit the
1099
# mode from the root directory
1100
temp_control = LockableFiles(transport, '', TransportLock)
1101
temp_control._transport.mkdir('.bzr',
1102
# FIXME: RBC 20060121 don't peek under
1104
mode=temp_control._dir_mode)
1105
file_mode = temp_control._file_mode
1107
mutter('created control directory in ' + transport.base)
1108
control = transport.clone('.bzr')
1109
utf8_files = [('README',
1110
"This is a Bazaar-NG control directory.\n"
1111
"Do not change any files in this directory.\n"),
1112
('branch-format', self.get_format_string()),
1114
# NB: no need to escape relative paths that are url safe.
1115
control_files = LockableFiles(control, self._lock_file_name,
1117
control_files.create_lock()
1118
control_files.lock_write()
1120
for file, content in utf8_files:
1121
control_files.put_utf8(file, content)
1123
control_files.unlock()
1124
return self.open(transport, _found=True)
1126
def is_supported(self):
1127
"""Is this format supported?
1129
Supported formats must be initializable and openable.
1130
Unsupported formats may not support initialization or committing or
1131
some other features depending on the reason for not being supported.
1135
def same_model(self, target_format):
1136
return (self.repository_format.rich_root_data ==
1137
target_format.rich_root_data)
1140
def known_formats(klass):
1141
"""Return all the known formats.
1143
Concrete formats should override _known_formats.
1145
# There is double indirection here to make sure that control
1146
# formats used by more than one dir format will only be probed
1147
# once. This can otherwise be quite expensive for remote connections.
1149
for format in klass._control_formats:
1150
result.update(format._known_formats())
1154
def _known_formats(klass):
1155
"""Return the known format instances for this control format."""
1156
return set(klass._formats.values())
1158
def open(self, transport, _found=False):
1159
"""Return an instance of this format for the dir transport points at.
1161
_found is a private parameter, do not use it.
1164
assert isinstance(BzrDirFormat.find_format(transport),
1166
return self._open(transport)
1168
def _open(self, transport):
1169
"""Template method helper for opening BzrDirectories.
1171
This performs the actual open and any additional logic or parameter
1174
raise NotImplementedError(self._open)
1177
def register_format(klass, format):
1178
klass._formats[format.get_format_string()] = format
1181
def register_control_format(klass, format):
1182
"""Register a format that does not use '.bzrdir' for its control dir.
1184
TODO: This should be pulled up into a 'ControlDirFormat' base class
1185
which BzrDirFormat can inherit from, and renamed to register_format
1186
there. It has been done without that for now for simplicity of
1189
klass._control_formats.append(format)
1192
def set_default_format(klass, format):
1193
klass._default_format = format
1196
return self.get_format_string()[:-1]
1199
def unregister_format(klass, format):
1200
assert klass._formats[format.get_format_string()] is format
1201
del klass._formats[format.get_format_string()]
1204
def unregister_control_format(klass, format):
1205
klass._control_formats.remove(format)
1208
# register BzrDirFormat as a control format
1209
BzrDirFormat.register_control_format(BzrDirFormat)
1212
class BzrDirFormat4(BzrDirFormat):
1213
"""Bzr dir format 4.
1215
This format is a combined format for working tree, branch and repository.
1217
- Format 1 working trees [always]
1218
- Format 4 branches [always]
1219
- Format 4 repositories [always]
1221
This format is deprecated: it indexes texts using a text it which is
1222
removed in format 5; write support for this format has been removed.
1225
_lock_class = TransportLock
1227
def get_format_string(self):
1228
"""See BzrDirFormat.get_format_string()."""
1229
return "Bazaar-NG branch, format 0.0.4\n"
1231
def get_format_description(self):
1232
"""See BzrDirFormat.get_format_description()."""
1233
return "All-in-one format 4"
1235
def get_converter(self, format=None):
1236
"""See BzrDirFormat.get_converter()."""
1237
# there is one and only one upgrade path here.
1238
return ConvertBzrDir4To5()
1240
def initialize_on_transport(self, transport):
1241
"""Format 4 branches cannot be created."""
1242
raise errors.UninitializableFormat(self)
1244
def is_supported(self):
1245
"""Format 4 is not supported.
1247
It is not supported because the model changed from 4 to 5 and the
1248
conversion logic is expensive - so doing it on the fly was not
1253
def _open(self, transport):
1254
"""See BzrDirFormat._open."""
1255
return BzrDir4(transport, self)
1257
def __return_repository_format(self):
1258
"""Circular import protection."""
1259
from bzrlib.repository import RepositoryFormat4
1260
return RepositoryFormat4()
1261
repository_format = property(__return_repository_format)
1264
class BzrDirFormat5(BzrDirFormat):
1265
"""Bzr control format 5.
1267
This format is a combined format for working tree, branch and repository.
1269
- Format 2 working trees [always]
1270
- Format 4 branches [always]
1271
- Format 5 repositories [always]
1272
Unhashed stores in the repository.
1275
_lock_class = TransportLock
1277
def get_format_string(self):
1278
"""See BzrDirFormat.get_format_string()."""
1279
return "Bazaar-NG branch, format 5\n"
1281
def get_format_description(self):
1282
"""See BzrDirFormat.get_format_description()."""
1283
return "All-in-one format 5"
1285
def get_converter(self, format=None):
1286
"""See BzrDirFormat.get_converter()."""
1287
# there is one and only one upgrade path here.
1288
return ConvertBzrDir5To6()
1290
def _initialize_for_clone(self, url):
1291
return self.initialize_on_transport(get_transport(url), _cloning=True)
1293
def initialize_on_transport(self, transport, _cloning=False):
1294
"""Format 5 dirs always have working tree, branch and repository.
1296
Except when they are being cloned.
1298
from bzrlib.branch import BzrBranchFormat4
1299
from bzrlib.repository import RepositoryFormat5
1300
from bzrlib.workingtree import WorkingTreeFormat2
1301
result = (super(BzrDirFormat5, self).initialize_on_transport(transport))
1302
RepositoryFormat5().initialize(result, _internal=True)
1304
branch = BzrBranchFormat4().initialize(result)
1306
WorkingTreeFormat2().initialize(result)
1307
except errors.NotLocalUrl:
1308
# Even though we can't access the working tree, we need to
1309
# create its control files.
1310
WorkingTreeFormat2().stub_initialize_remote(branch.control_files)
1313
def _open(self, transport):
1314
"""See BzrDirFormat._open."""
1315
return BzrDir5(transport, self)
1317
def __return_repository_format(self):
1318
"""Circular import protection."""
1319
from bzrlib.repository import RepositoryFormat5
1320
return RepositoryFormat5()
1321
repository_format = property(__return_repository_format)
1324
class BzrDirFormat6(BzrDirFormat):
1325
"""Bzr control format 6.
1327
This format is a combined format for working tree, branch and repository.
1329
- Format 2 working trees [always]
1330
- Format 4 branches [always]
1331
- Format 6 repositories [always]
1334
_lock_class = TransportLock
1336
def get_format_string(self):
1337
"""See BzrDirFormat.get_format_string()."""
1338
return "Bazaar-NG branch, format 6\n"
1340
def get_format_description(self):
1341
"""See BzrDirFormat.get_format_description()."""
1342
return "All-in-one format 6"
1344
def get_converter(self, format=None):
1345
"""See BzrDirFormat.get_converter()."""
1346
# there is one and only one upgrade path here.
1347
return ConvertBzrDir6ToMeta()
1349
def _initialize_for_clone(self, url):
1350
return self.initialize_on_transport(get_transport(url), _cloning=True)
1352
def initialize_on_transport(self, transport, _cloning=False):
1353
"""Format 6 dirs always have working tree, branch and repository.
1355
Except when they are being cloned.
1357
from bzrlib.branch import BzrBranchFormat4
1358
from bzrlib.repository import RepositoryFormat6
1359
from bzrlib.workingtree import WorkingTreeFormat2
1360
result = super(BzrDirFormat6, self).initialize_on_transport(transport)
1361
RepositoryFormat6().initialize(result, _internal=True)
1363
branch = BzrBranchFormat4().initialize(result)
1365
WorkingTreeFormat2().initialize(result)
1366
except errors.NotLocalUrl:
1367
# Even though we can't access the working tree, we need to
1368
# create its control files.
1369
WorkingTreeFormat2().stub_initialize_remote(branch.control_files)
1372
def _open(self, transport):
1373
"""See BzrDirFormat._open."""
1374
return BzrDir6(transport, self)
1376
def __return_repository_format(self):
1377
"""Circular import protection."""
1378
from bzrlib.repository import RepositoryFormat6
1379
return RepositoryFormat6()
1380
repository_format = property(__return_repository_format)
1383
class BzrDirMetaFormat1(BzrDirFormat):
1384
"""Bzr meta control format 1
1386
This is the first format with split out working tree, branch and repository
1389
- Format 3 working trees [optional]
1390
- Format 5 branches [optional]
1391
- Format 7 repositories [optional]
1394
_lock_class = LockDir
1396
def get_converter(self, format=None):
1397
"""See BzrDirFormat.get_converter()."""
1399
format = BzrDirFormat.get_default_format()
1400
if not isinstance(self, format.__class__):
1401
# converting away from metadir is not implemented
1402
raise NotImplementedError(self.get_converter)
1403
return ConvertMetaToMeta(format)
1405
def get_format_string(self):
1406
"""See BzrDirFormat.get_format_string()."""
1407
return "Bazaar-NG meta directory, format 1\n"
1409
def get_format_description(self):
1410
"""See BzrDirFormat.get_format_description()."""
1411
return "Meta directory format 1"
1413
def _open(self, transport):
1414
"""See BzrDirFormat._open."""
1415
return BzrDirMeta1(transport, self)
1417
def __return_repository_format(self):
1418
"""Circular import protection."""
1419
if getattr(self, '_repository_format', None):
1420
return self._repository_format
1421
from bzrlib.repository import RepositoryFormat
1422
return RepositoryFormat.get_default_format()
1424
def __set_repository_format(self, value):
1425
"""Allow changint the repository format for metadir formats."""
1426
self._repository_format = value
1428
repository_format = property(__return_repository_format, __set_repository_format)
1431
BzrDirFormat.register_format(BzrDirFormat4())
1432
BzrDirFormat.register_format(BzrDirFormat5())
1433
BzrDirFormat.register_format(BzrDirFormat6())
1434
__default_format = BzrDirMetaFormat1()
1435
BzrDirFormat.register_format(__default_format)
1436
BzrDirFormat.set_default_format(__default_format)
1439
class BzrDirTestProviderAdapter(object):
1440
"""A tool to generate a suite testing multiple bzrdir formats at once.
1442
This is done by copying the test once for each transport and injecting
1443
the transport_server, transport_readonly_server, and bzrdir_format
1444
classes into each copy. Each copy is also given a new id() to make it
1448
def __init__(self, transport_server, transport_readonly_server, formats):
1449
self._transport_server = transport_server
1450
self._transport_readonly_server = transport_readonly_server
1451
self._formats = formats
1453
def adapt(self, test):
1454
result = TestSuite()
1455
for format in self._formats:
1456
new_test = deepcopy(test)
1457
new_test.transport_server = self._transport_server
1458
new_test.transport_readonly_server = self._transport_readonly_server
1459
new_test.bzrdir_format = format
1460
def make_new_test_id():
1461
new_id = "%s(%s)" % (new_test.id(), format.__class__.__name__)
1462
return lambda: new_id
1463
new_test.id = make_new_test_id()
1464
result.addTest(new_test)
1468
class Converter(object):
1469
"""Converts a disk format object from one format to another."""
1471
def convert(self, to_convert, pb):
1472
"""Perform the conversion of to_convert, giving feedback via pb.
1474
:param to_convert: The disk object to convert.
1475
:param pb: a progress bar to use for progress information.
1478
def step(self, message):
1479
"""Update the pb by a step."""
1481
self.pb.update(message, self.count, self.total)
1484
class ConvertBzrDir4To5(Converter):
1485
"""Converts format 4 bzr dirs to format 5."""
1488
super(ConvertBzrDir4To5, self).__init__()
1489
self.converted_revs = set()
1490
self.absent_revisions = set()
1494
def convert(self, to_convert, pb):
1495
"""See Converter.convert()."""
1496
self.bzrdir = to_convert
1498
self.pb.note('starting upgrade from format 4 to 5')
1499
if isinstance(self.bzrdir.transport, LocalTransport):
1500
self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
1501
self._convert_to_weaves()
1502
return BzrDir.open(self.bzrdir.root_transport.base)
1504
def _convert_to_weaves(self):
1505
self.pb.note('note: upgrade may be faster if all store files are ungzipped first')
1508
stat = self.bzrdir.transport.stat('weaves')
1509
if not S_ISDIR(stat.st_mode):
1510
self.bzrdir.transport.delete('weaves')
1511
self.bzrdir.transport.mkdir('weaves')
1512
except errors.NoSuchFile:
1513
self.bzrdir.transport.mkdir('weaves')
1514
# deliberately not a WeaveFile as we want to build it up slowly.
1515
self.inv_weave = Weave('inventory')
1516
# holds in-memory weaves for all files
1517
self.text_weaves = {}
1518
self.bzrdir.transport.delete('branch-format')
1519
self.branch = self.bzrdir.open_branch()
1520
self._convert_working_inv()
1521
rev_history = self.branch.revision_history()
1522
# to_read is a stack holding the revisions we still need to process;
1523
# appending to it adds new highest-priority revisions
1524
self.known_revisions = set(rev_history)
1525
self.to_read = rev_history[-1:]
1527
rev_id = self.to_read.pop()
1528
if (rev_id not in self.revisions
1529
and rev_id not in self.absent_revisions):
1530
self._load_one_rev(rev_id)
1532
to_import = self._make_order()
1533
for i, rev_id in enumerate(to_import):
1534
self.pb.update('converting revision', i, len(to_import))
1535
self._convert_one_rev(rev_id)
1537
self._write_all_weaves()
1538
self._write_all_revs()
1539
self.pb.note('upgraded to weaves:')
1540
self.pb.note(' %6d revisions and inventories', len(self.revisions))
1541
self.pb.note(' %6d revisions not present', len(self.absent_revisions))
1542
self.pb.note(' %6d texts', self.text_count)
1543
self._cleanup_spare_files_after_format4()
1544
self.branch.control_files.put_utf8('branch-format', BzrDirFormat5().get_format_string())
1546
def _cleanup_spare_files_after_format4(self):
1547
# FIXME working tree upgrade foo.
1548
for n in 'merged-patches', 'pending-merged-patches':
1550
## assert os.path.getsize(p) == 0
1551
self.bzrdir.transport.delete(n)
1552
except errors.NoSuchFile:
1554
self.bzrdir.transport.delete_tree('inventory-store')
1555
self.bzrdir.transport.delete_tree('text-store')
1557
def _convert_working_inv(self):
1558
inv = serializer_v4.read_inventory(self.branch.control_files.get('inventory'))
1559
new_inv_xml = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)
1560
# FIXME inventory is a working tree change.
1561
self.branch.control_files.put('inventory', StringIO(new_inv_xml))
1563
def _write_all_weaves(self):
1564
controlweaves = WeaveStore(self.bzrdir.transport, prefixed=False)
1565
weave_transport = self.bzrdir.transport.clone('weaves')
1566
weaves = WeaveStore(weave_transport, prefixed=False)
1567
transaction = WriteTransaction()
1571
for file_id, file_weave in self.text_weaves.items():
1572
self.pb.update('writing weave', i, len(self.text_weaves))
1573
weaves._put_weave(file_id, file_weave, transaction)
1575
self.pb.update('inventory', 0, 1)
1576
controlweaves._put_weave('inventory', self.inv_weave, transaction)
1577
self.pb.update('inventory', 1, 1)
1581
def _write_all_revs(self):
1582
"""Write all revisions out in new form."""
1583
self.bzrdir.transport.delete_tree('revision-store')
1584
self.bzrdir.transport.mkdir('revision-store')
1585
revision_transport = self.bzrdir.transport.clone('revision-store')
1587
_revision_store = TextRevisionStore(TextStore(revision_transport,
1591
transaction = bzrlib.transactions.WriteTransaction()
1592
for i, rev_id in enumerate(self.converted_revs):
1593
self.pb.update('write revision', i, len(self.converted_revs))
1594
_revision_store.add_revision(self.revisions[rev_id], transaction)
1598
def _load_one_rev(self, rev_id):
1599
"""Load a revision object into memory.
1601
Any parents not either loaded or abandoned get queued to be
1603
self.pb.update('loading revision',
1604
len(self.revisions),
1605
len(self.known_revisions))
1606
if not self.branch.repository.has_revision(rev_id):
1608
self.pb.note('revision {%s} not present in branch; '
1609
'will be converted as a ghost',
1611
self.absent_revisions.add(rev_id)
1613
rev = self.branch.repository._revision_store.get_revision(rev_id,
1614
self.branch.repository.get_transaction())
1615
for parent_id in rev.parent_ids:
1616
self.known_revisions.add(parent_id)
1617
self.to_read.append(parent_id)
1618
self.revisions[rev_id] = rev
1620
def _load_old_inventory(self, rev_id):
1621
assert rev_id not in self.converted_revs
1622
old_inv_xml = self.branch.repository.inventory_store.get(rev_id).read()
1623
inv = serializer_v4.read_inventory_from_string(old_inv_xml)
1624
inv.revision_id = rev_id
1625
rev = self.revisions[rev_id]
1626
if rev.inventory_sha1:
1627
assert rev.inventory_sha1 == sha_string(old_inv_xml), \
1628
'inventory sha mismatch for {%s}' % rev_id
1631
def _load_updated_inventory(self, rev_id):
1632
assert rev_id in self.converted_revs
1633
inv_xml = self.inv_weave.get_text(rev_id)
1634
inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(inv_xml)
1637
def _convert_one_rev(self, rev_id):
1638
"""Convert revision and all referenced objects to new format."""
1639
rev = self.revisions[rev_id]
1640
inv = self._load_old_inventory(rev_id)
1641
present_parents = [p for p in rev.parent_ids
1642
if p not in self.absent_revisions]
1643
self._convert_revision_contents(rev, inv, present_parents)
1644
self._store_new_weave(rev, inv, present_parents)
1645
self.converted_revs.add(rev_id)
1647
def _store_new_weave(self, rev, inv, present_parents):
1648
# the XML is now updated with text versions
1650
entries = inv.iter_entries()
1652
for path, ie in entries:
1653
assert getattr(ie, 'revision', None) is not None, \
1654
'no revision on {%s} in {%s}' % \
1655
(file_id, rev.revision_id)
1656
new_inv_xml = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)
1657
new_inv_sha1 = sha_string(new_inv_xml)
1658
self.inv_weave.add_lines(rev.revision_id,
1660
new_inv_xml.splitlines(True))
1661
rev.inventory_sha1 = new_inv_sha1
1663
def _convert_revision_contents(self, rev, inv, present_parents):
1664
"""Convert all the files within a revision.
1666
Also upgrade the inventory to refer to the text revision ids."""
1667
rev_id = rev.revision_id
1668
mutter('converting texts of revision {%s}',
1670
parent_invs = map(self._load_updated_inventory, present_parents)
1671
entries = inv.iter_entries()
1673
for path, ie in entries:
1674
self._convert_file_version(rev, ie, parent_invs)
1676
def _convert_file_version(self, rev, ie, parent_invs):
1677
"""Convert one version of one file.
1679
The file needs to be added into the weave if it is a merge
1680
of >=2 parents or if it's changed from its parent.
1682
file_id = ie.file_id
1683
rev_id = rev.revision_id
1684
w = self.text_weaves.get(file_id)
1687
self.text_weaves[file_id] = w
1688
text_changed = False
1689
previous_entries = ie.find_previous_heads(parent_invs,
1693
for old_revision in previous_entries:
1694
# if this fails, its a ghost ?
1695
assert old_revision in self.converted_revs
1696
self.snapshot_ie(previous_entries, ie, w, rev_id)
1698
assert getattr(ie, 'revision', None) is not None
1700
def snapshot_ie(self, previous_revisions, ie, w, rev_id):
1701
# TODO: convert this logic, which is ~= snapshot to
1702
# a call to:. This needs the path figured out. rather than a work_tree
1703
# a v4 revision_tree can be given, or something that looks enough like
1704
# one to give the file content to the entry if it needs it.
1705
# and we need something that looks like a weave store for snapshot to
1707
#ie.snapshot(rev, PATH, previous_revisions, REVISION_TREE, InMemoryWeaveStore(self.text_weaves))
1708
if len(previous_revisions) == 1:
1709
previous_ie = previous_revisions.values()[0]
1710
if ie._unchanged(previous_ie):
1711
ie.revision = previous_ie.revision
1714
text = self.branch.repository.text_store.get(ie.text_id)
1715
file_lines = text.readlines()
1716
assert sha_strings(file_lines) == ie.text_sha1
1717
assert sum(map(len, file_lines)) == ie.text_size
1718
w.add_lines(rev_id, previous_revisions, file_lines)
1719
self.text_count += 1
1721
w.add_lines(rev_id, previous_revisions, [])
1722
ie.revision = rev_id
1724
def _make_order(self):
1725
"""Return a suitable order for importing revisions.
1727
The order must be such that an revision is imported after all
1728
its (present) parents.
1730
todo = set(self.revisions.keys())
1731
done = self.absent_revisions.copy()
1734
# scan through looking for a revision whose parents
1736
for rev_id in sorted(list(todo)):
1737
rev = self.revisions[rev_id]
1738
parent_ids = set(rev.parent_ids)
1739
if parent_ids.issubset(done):
1740
# can take this one now
1741
order.append(rev_id)
1747
class ConvertBzrDir5To6(Converter):
1748
"""Converts format 5 bzr dirs to format 6."""
1750
def convert(self, to_convert, pb):
1751
"""See Converter.convert()."""
1752
self.bzrdir = to_convert
1754
self.pb.note('starting upgrade from format 5 to 6')
1755
self._convert_to_prefixed()
1756
return BzrDir.open(self.bzrdir.root_transport.base)
1758
def _convert_to_prefixed(self):
1759
from bzrlib.store import TransportStore
1760
self.bzrdir.transport.delete('branch-format')
1761
for store_name in ["weaves", "revision-store"]:
1762
self.pb.note("adding prefixes to %s" % store_name)
1763
store_transport = self.bzrdir.transport.clone(store_name)
1764
store = TransportStore(store_transport, prefixed=True)
1765
for urlfilename in store_transport.list_dir('.'):
1766
filename = urlutils.unescape(urlfilename)
1767
if (filename.endswith(".weave") or
1768
filename.endswith(".gz") or
1769
filename.endswith(".sig")):
1770
file_id = os.path.splitext(filename)[0]
1773
prefix_dir = store.hash_prefix(file_id)
1774
# FIXME keep track of the dirs made RBC 20060121
1776
store_transport.move(filename, prefix_dir + '/' + filename)
1777
except errors.NoSuchFile: # catches missing dirs strangely enough
1778
store_transport.mkdir(prefix_dir)
1779
store_transport.move(filename, prefix_dir + '/' + filename)
1780
self.bzrdir._control_files.put_utf8('branch-format', BzrDirFormat6().get_format_string())
1783
class ConvertBzrDir6ToMeta(Converter):
1784
"""Converts format 6 bzr dirs to metadirs."""
1786
def convert(self, to_convert, pb):
1787
"""See Converter.convert()."""
1788
self.bzrdir = to_convert
1791
self.total = 20 # the steps we know about
1792
self.garbage_inventories = []
1794
self.pb.note('starting upgrade from format 6 to metadir')
1795
self.bzrdir._control_files.put_utf8('branch-format', "Converting to format 6")
1796
# its faster to move specific files around than to open and use the apis...
1797
# first off, nuke ancestry.weave, it was never used.
1799
self.step('Removing ancestry.weave')
1800
self.bzrdir.transport.delete('ancestry.weave')
1801
except errors.NoSuchFile:
1803
# find out whats there
1804
self.step('Finding branch files')
1805
last_revision = self.bzrdir.open_branch().last_revision()
1806
bzrcontents = self.bzrdir.transport.list_dir('.')
1807
for name in bzrcontents:
1808
if name.startswith('basis-inventory.'):
1809
self.garbage_inventories.append(name)
1810
# create new directories for repository, working tree and branch
1811
self.dir_mode = self.bzrdir._control_files._dir_mode
1812
self.file_mode = self.bzrdir._control_files._file_mode
1813
repository_names = [('inventory.weave', True),
1814
('revision-store', True),
1816
self.step('Upgrading repository ')
1817
self.bzrdir.transport.mkdir('repository', mode=self.dir_mode)
1818
self.make_lock('repository')
1819
# we hard code the formats here because we are converting into
1820
# the meta format. The meta format upgrader can take this to a
1821
# future format within each component.
1822
self.put_format('repository', bzrlib.repository.RepositoryFormat7())
1823
for entry in repository_names:
1824
self.move_entry('repository', entry)
1826
self.step('Upgrading branch ')
1827
self.bzrdir.transport.mkdir('branch', mode=self.dir_mode)
1828
self.make_lock('branch')
1829
self.put_format('branch', bzrlib.branch.BzrBranchFormat5())
1830
branch_files = [('revision-history', True),
1831
('branch-name', True),
1833
for entry in branch_files:
1834
self.move_entry('branch', entry)
1836
checkout_files = [('pending-merges', True),
1837
('inventory', True),
1838
('stat-cache', False)]
1839
# If a mandatory checkout file is not present, the branch does not have
1840
# a functional checkout. Do not create a checkout in the converted
1842
for name, mandatory in checkout_files:
1843
if mandatory and name not in bzrcontents:
1844
has_checkout = False
1848
if not has_checkout:
1849
self.pb.note('No working tree.')
1850
# If some checkout files are there, we may as well get rid of them.
1851
for name, mandatory in checkout_files:
1852
if name in bzrcontents:
1853
self.bzrdir.transport.delete(name)
1855
self.step('Upgrading working tree')
1856
self.bzrdir.transport.mkdir('checkout', mode=self.dir_mode)
1857
self.make_lock('checkout')
1859
'checkout', bzrlib.workingtree.WorkingTreeFormat3())
1860
self.bzrdir.transport.delete_multi(
1861
self.garbage_inventories, self.pb)
1862
for entry in checkout_files:
1863
self.move_entry('checkout', entry)
1864
if last_revision is not None:
1865
self.bzrdir._control_files.put_utf8(
1866
'checkout/last-revision', last_revision)
1867
self.bzrdir._control_files.put_utf8(
1868
'branch-format', BzrDirMetaFormat1().get_format_string())
1869
return BzrDir.open(self.bzrdir.root_transport.base)
1871
def make_lock(self, name):
1872
"""Make a lock for the new control dir name."""
1873
self.step('Make %s lock' % name)
1874
ld = LockDir(self.bzrdir.transport,
1876
file_modebits=self.file_mode,
1877
dir_modebits=self.dir_mode)
1880
def move_entry(self, new_dir, entry):
1881
"""Move then entry name into new_dir."""
1883
mandatory = entry[1]
1884
self.step('Moving %s' % name)
1886
self.bzrdir.transport.move(name, '%s/%s' % (new_dir, name))
1887
except errors.NoSuchFile:
1891
def put_format(self, dirname, format):
1892
self.bzrdir._control_files.put_utf8('%s/format' % dirname, format.get_format_string())
1895
class ConvertMetaToMeta(Converter):
1896
"""Converts the components of metadirs."""
1898
def __init__(self, target_format):
1899
"""Create a metadir to metadir converter.
1901
:param target_format: The final metadir format that is desired.
1903
self.target_format = target_format
1905
def convert(self, to_convert, pb):
1906
"""See Converter.convert()."""
1907
self.bzrdir = to_convert
1911
self.step('checking repository format')
1913
repo = self.bzrdir.open_repository()
1914
except errors.NoRepositoryPresent:
1917
if not isinstance(repo._format, self.target_format.repository_format.__class__):
1918
from bzrlib.repository import CopyConverter
1919
self.pb.note('starting repository conversion')
1920
converter = CopyConverter(self.target_format.repository_format)
1921
converter.convert(repo, pb)
added
removed
bzrlib/bzrdir.py
