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
from copy import deepcopy
25
from cStringIO import StringIO
26
from unittest import TestSuite
29
import bzrlib.errors as errors
30
from bzrlib.lockable_files import LockableFiles, TransportLock
31
from bzrlib.lockdir import LockDir
32
from bzrlib.osutils import (
39
from bzrlib.store.revision.text import TextRevisionStore
40
from bzrlib.store.text import TextStore
41
from bzrlib.store.versioned import WeaveStore
42
from bzrlib.symbol_versioning import *
43
from bzrlib.trace import mutter
44
from bzrlib.transactions import WriteTransaction
45
from bzrlib.transport import get_transport
46
from bzrlib.transport.local import LocalTransport
47
import bzrlib.urlutils as urlutils
48
from bzrlib.weave import Weave
49
from bzrlib.xml4 import serializer_v4
54
"""A .bzr control diretory.
56
BzrDir instances let you create or open any of the things that can be
57
found within .bzr - checkouts, branches and repositories.
60
the transport which this bzr dir is rooted at (i.e. file:///.../.bzr/)
62
a transport connected to the directory this bzr was opened from.
66
"""Invoke break_lock on the first object in the bzrdir.
68
If there is a tree, the tree is opened and break_lock() called.
69
Otherwise, branch is tried, and finally repository.
72
thing_to_unlock = self.open_workingtree()
73
except (errors.NotLocalUrl, errors.NoWorkingTree):
75
thing_to_unlock = self.open_branch()
76
except errors.NotBranchError:
78
thing_to_unlock = self.open_repository()
79
except errors.NoRepositoryPresent:
81
thing_to_unlock.break_lock()
83
def can_convert_format(self):
84
"""Return true if this bzrdir is one whose format we can convert from."""
88
def _check_supported(format, allow_unsupported):
89
"""Check whether format is a supported format.
91
If allow_unsupported is True, this is a no-op.
93
if not allow_unsupported and not format.is_supported():
94
# see open_downlevel to open legacy branches.
95
raise errors.UnsupportedFormatError(
96
'sorry, format %s not supported' % format,
97
['use a different bzr version',
98
'or remove the .bzr directory'
99
' and "bzr init" again'])
101
def clone(self, url, revision_id=None, basis=None, force_new_repo=False):
102
"""Clone this bzrdir and its contents to url verbatim.
104
If urls last component does not exist, it will be created.
106
if revision_id is not None, then the clone operation may tune
107
itself to download less data.
108
:param force_new_repo: Do not use a shared repository for the target
109
even if one is available.
112
basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
113
result = self._format.initialize(url)
115
local_repo = self.find_repository()
116
except errors.NoRepositoryPresent:
119
# may need to copy content in
121
result_repo = local_repo.clone(
123
revision_id=revision_id,
125
result_repo.set_make_working_trees(local_repo.make_working_trees())
128
result_repo = result.find_repository()
129
# fetch content this dir needs.
131
# XXX FIXME RBC 20060214 need tests for this when the basis
133
result_repo.fetch(basis_repo, revision_id=revision_id)
134
result_repo.fetch(local_repo, revision_id=revision_id)
135
except errors.NoRepositoryPresent:
136
# needed to make one anyway.
137
result_repo = local_repo.clone(
139
revision_id=revision_id,
141
result_repo.set_make_working_trees(local_repo.make_working_trees())
142
# 1 if there is a branch present
143
# make sure its content is available in the target repository
146
self.open_branch().clone(result, revision_id=revision_id)
147
except errors.NotBranchError:
150
self.open_workingtree().clone(result, basis=basis_tree)
151
except (errors.NoWorkingTree, errors.NotLocalUrl):
155
def _get_basis_components(self, basis):
156
"""Retrieve the basis components that are available at basis."""
158
return None, None, None
160
basis_tree = basis.open_workingtree()
161
basis_branch = basis_tree.branch
162
basis_repo = basis_branch.repository
163
except (errors.NoWorkingTree, errors.NotLocalUrl):
166
basis_branch = basis.open_branch()
167
basis_repo = basis_branch.repository
168
except errors.NotBranchError:
171
basis_repo = basis.open_repository()
172
except errors.NoRepositoryPresent:
174
return basis_repo, basis_branch, basis_tree
176
# TODO: This should be given a Transport, and should chdir up; otherwise
177
# this will open a new connection.
178
def _make_tail(self, url):
179
head, tail = urlutils.split(url)
180
if tail and tail != '.':
181
t = bzrlib.transport.get_transport(head)
184
except errors.FileExists:
187
# TODO: Should take a Transport
189
def create(cls, base):
190
"""Create a new BzrDir at the url 'base'.
192
This will call the current default formats initialize with base
193
as the only parameter.
195
If you need a specific format, consider creating an instance
196
of that and calling initialize().
198
if cls is not BzrDir:
199
raise AssertionError("BzrDir.create always creates the default format, "
200
"not one of %r" % cls)
201
head, tail = urlutils.split(base)
202
if tail and tail != '.':
203
t = bzrlib.transport.get_transport(head)
206
except errors.FileExists:
208
return BzrDirFormat.get_default_format().initialize(safe_unicode(base))
210
def create_branch(self):
211
"""Create a branch in this BzrDir.
213
The bzrdirs format will control what branch format is created.
214
For more control see BranchFormatXX.create(a_bzrdir).
216
raise NotImplementedError(self.create_branch)
219
def create_branch_and_repo(base, force_new_repo=False):
220
"""Create a new BzrDir, Branch and Repository at the url 'base'.
222
This will use the current default BzrDirFormat, and use whatever
223
repository format that that uses via bzrdir.create_branch and
224
create_repository. If a shared repository is available that is used
227
The created Branch object is returned.
229
:param base: The URL to create the branch at.
230
:param force_new_repo: If True a new repository is always created.
232
bzrdir = BzrDir.create(base)
233
bzrdir._find_or_create_repository(force_new_repo)
234
return bzrdir.create_branch()
236
def _find_or_create_repository(self, force_new_repo):
237
"""Create a new repository if needed, returning the repository."""
239
return self.create_repository()
241
return self.find_repository()
242
except errors.NoRepositoryPresent:
243
return self.create_repository()
246
def create_branch_convenience(base, force_new_repo=False,
247
force_new_tree=None, format=None):
248
"""Create a new BzrDir, Branch and Repository at the url 'base'.
250
This is a convenience function - it will use an existing repository
251
if possible, can be told explicitly whether to create a working tree or
254
This will use the current default BzrDirFormat, and use whatever
255
repository format that that uses via bzrdir.create_branch and
256
create_repository. If a shared repository is available that is used
257
preferentially. Whatever repository is used, its tree creation policy
260
The created Branch object is returned.
261
If a working tree cannot be made due to base not being a file:// url,
262
no error is raised unless force_new_tree is True, in which case no
263
data is created on disk and NotLocalUrl is raised.
265
:param base: The URL to create the branch at.
266
:param force_new_repo: If True a new repository is always created.
267
:param force_new_tree: If True or False force creation of a tree or
268
prevent such creation respectively.
269
:param format: Override for the for the bzrdir format to create
272
# check for non local urls
273
t = get_transport(safe_unicode(base))
274
if not isinstance(t, LocalTransport):
275
raise errors.NotLocalUrl(base)
277
bzrdir = BzrDir.create(base)
279
bzrdir = format.initialize(base)
280
repo = bzrdir._find_or_create_repository(force_new_repo)
281
result = bzrdir.create_branch()
282
if force_new_tree or (repo.make_working_trees() and
283
force_new_tree is None):
285
bzrdir.create_workingtree()
286
except errors.NotLocalUrl:
291
def create_repository(base, shared=False):
292
"""Create a new BzrDir and Repository at the url 'base'.
294
This will use the current default BzrDirFormat, and use whatever
295
repository format that that uses for bzrdirformat.create_repository.
297
;param shared: Create a shared repository rather than a standalone
299
The Repository object is returned.
301
This must be overridden as an instance method in child classes, where
302
it should take no parameters and construct whatever repository format
303
that child class desires.
305
bzrdir = BzrDir.create(base)
306
return bzrdir.create_repository()
309
def create_standalone_workingtree(base):
310
"""Create a new BzrDir, WorkingTree, Branch and Repository at 'base'.
312
'base' must be a local path or a file:// url.
314
This will use the current default BzrDirFormat, and use whatever
315
repository format that that uses for bzrdirformat.create_workingtree,
316
create_branch and create_repository.
318
The WorkingTree object is returned.
320
t = get_transport(safe_unicode(base))
321
if not isinstance(t, LocalTransport):
322
raise errors.NotLocalUrl(base)
323
bzrdir = BzrDir.create_branch_and_repo(safe_unicode(base),
324
force_new_repo=True).bzrdir
325
return bzrdir.create_workingtree()
327
def create_workingtree(self, revision_id=None):
328
"""Create a working tree at this BzrDir.
330
revision_id: create it as of this revision id.
332
raise NotImplementedError(self.create_workingtree)
334
def find_repository(self):
335
"""Find the repository that should be used for a_bzrdir.
337
This does not require a branch as we use it to find the repo for
338
new branches as well as to hook existing branches up to their
342
return self.open_repository()
343
except errors.NoRepositoryPresent:
345
next_transport = self.root_transport.clone('..')
347
# find the next containing bzrdir
349
found_bzrdir = BzrDir.open_containing_from_transport(
351
except errors.NotBranchError:
353
raise errors.NoRepositoryPresent(self)
354
# does it have a repository ?
356
repository = found_bzrdir.open_repository()
357
except errors.NoRepositoryPresent:
358
next_transport = found_bzrdir.root_transport.clone('..')
359
if (found_bzrdir.root_transport.base == next_transport.base):
360
# top of the file system
364
if ((found_bzrdir.root_transport.base ==
365
self.root_transport.base) or repository.is_shared()):
368
raise errors.NoRepositoryPresent(self)
369
raise errors.NoRepositoryPresent(self)
371
def get_branch_transport(self, branch_format):
372
"""Get the transport for use by branch format in this BzrDir.
374
Note that bzr dirs that do not support format strings will raise
375
IncompatibleFormat if the branch format they are given has
376
a format string, and vice versa.
378
If branch_format is None, the transport is returned with no
379
checking. if it is not None, then the returned transport is
380
guaranteed to point to an existing directory ready for use.
382
raise NotImplementedError(self.get_branch_transport)
384
def get_repository_transport(self, repository_format):
385
"""Get the transport for use by repository format in this BzrDir.
387
Note that bzr dirs that do not support format strings will raise
388
IncompatibleFormat if the repository format they are given has
389
a format string, and vice versa.
391
If repository_format is None, the transport is returned with no
392
checking. if it is not None, then the returned transport is
393
guaranteed to point to an existing directory ready for use.
395
raise NotImplementedError(self.get_repository_transport)
397
def get_workingtree_transport(self, tree_format):
398
"""Get the transport for use by workingtree format in this BzrDir.
400
Note that bzr dirs that do not support format strings will raise
401
IncompatibleFormat if the workingtree format they are given has
402
a format string, and vice versa.
404
If workingtree_format is None, the transport is returned with no
405
checking. if it is not None, then the returned transport is
406
guaranteed to point to an existing directory ready for use.
408
raise NotImplementedError(self.get_workingtree_transport)
410
def __init__(self, _transport, _format):
411
"""Initialize a Bzr control dir object.
413
Only really common logic should reside here, concrete classes should be
414
made with varying behaviours.
416
:param _format: the format that is creating this BzrDir instance.
417
:param _transport: the transport this dir is based at.
419
self._format = _format
420
self.transport = _transport.clone('.bzr')
421
self.root_transport = _transport
423
def is_control_filename(self, filename):
424
"""True if filename is the name of a path which is reserved for bzrdir's.
426
:param filename: A filename within the root transport of this bzrdir.
428
This is true IF and ONLY IF the filename is part of the namespace reserved
429
for bzr control dirs. Currently this is the '.bzr' directory in the root
430
of the root_transport. it is expected that plugins will need to extend
431
this in the future - for instance to make bzr talk with svn working
434
# this might be better on the BzrDirFormat class because it refers to
435
# all the possible bzrdir disk formats.
436
# This method is tested via the workingtree is_control_filename tests-
437
# it was extracted from WorkingTree.is_control_filename. If the methods
438
# contract is extended beyond the current trivial implementation please
439
# add new tests for it to the appropriate place.
440
return filename == '.bzr' or filename.startswith('.bzr/')
442
def needs_format_conversion(self, format=None):
443
"""Return true if this bzrdir needs convert_format run on it.
445
For instance, if the repository format is out of date but the
446
branch and working tree are not, this should return True.
448
:param format: Optional parameter indicating a specific desired
449
format we plan to arrive at.
451
raise NotImplementedError(self.needs_format_conversion)
454
def open_unsupported(base):
455
"""Open a branch which is not supported."""
456
return BzrDir.open(base, _unsupported=True)
459
def open(base, _unsupported=False):
460
"""Open an existing bzrdir, rooted at 'base' (url)
462
_unsupported is a private parameter to the BzrDir class.
464
t = get_transport(base)
465
mutter("trying to open %r with transport %r", base, t)
466
format = BzrDirFormat.find_format(t)
467
BzrDir._check_supported(format, _unsupported)
468
return format.open(t, _found=True)
470
def open_branch(self, unsupported=False):
471
"""Open the branch object at this BzrDir if one is present.
473
If unsupported is True, then no longer supported branch formats can
476
TODO: static convenience version of this?
478
raise NotImplementedError(self.open_branch)
481
def open_containing(url):
482
"""Open an existing branch which contains url.
484
:param url: url to search from.
485
See open_containing_from_transport for more detail.
487
return BzrDir.open_containing_from_transport(get_transport(url))
490
def open_containing_from_transport(a_transport):
491
"""Open an existing branch which contains a_transport.base
493
This probes for a branch at a_transport, and searches upwards from there.
495
Basically we keep looking up until we find the control directory or
496
run into the root. If there isn't one, raises NotBranchError.
497
If there is one and it is either an unrecognised format or an unsupported
498
format, UnknownFormatError or UnsupportedFormatError are raised.
499
If there is one, it is returned, along with the unused portion of url.
501
:return: The BzrDir that contains the path, and a Unicode path
502
for the rest of the URL.
504
# this gets the normalised url back. I.e. '.' -> the full path.
505
url = a_transport.base
508
format = BzrDirFormat.find_format(a_transport)
509
BzrDir._check_supported(format, False)
510
return format.open(a_transport), urlutils.unescape(a_transport.relpath(url))
511
except errors.NotBranchError, e:
512
## mutter('not a branch in: %r %s', a_transport.base, e)
514
new_t = a_transport.clone('..')
515
if new_t.base == a_transport.base:
516
# reached the root, whatever that may be
517
raise errors.NotBranchError(path=url)
520
def open_repository(self, _unsupported=False):
521
"""Open the repository object at this BzrDir if one is present.
523
This will not follow the Branch object pointer - its strictly a direct
524
open facility. Most client code should use open_branch().repository to
527
_unsupported is a private parameter, not part of the api.
528
TODO: static convenience version of this?
530
raise NotImplementedError(self.open_repository)
532
def open_workingtree(self, _unsupported=False):
533
"""Open the workingtree object at this BzrDir if one is present.
535
TODO: static convenience version of this?
537
raise NotImplementedError(self.open_workingtree)
539
def has_branch(self):
540
"""Tell if this bzrdir contains a branch.
542
Note: if you're going to open the branch, you should just go ahead
543
and try, and not ask permission first. (This method just opens the
544
branch and discards it, and that's somewhat expensive.)
549
except errors.NotBranchError:
552
def has_workingtree(self):
553
"""Tell if this bzrdir contains a working tree.
555
This will still raise an exception if the bzrdir has a workingtree that
556
is remote & inaccessible.
558
Note: if you're going to open the working tree, you should just go ahead
559
and try, and not ask permission first. (This method just opens the
560
workingtree and discards it, and that's somewhat expensive.)
563
self.open_workingtree()
565
except errors.NoWorkingTree:
568
def sprout(self, url, revision_id=None, basis=None, force_new_repo=False):
569
"""Create a copy of this bzrdir prepared for use as a new line of
572
If urls last component does not exist, it will be created.
574
Attributes related to the identity of the source branch like
575
branch nickname will be cleaned, a working tree is created
576
whether one existed before or not; and a local branch is always
579
if revision_id is not None, then the clone operation may tune
580
itself to download less data.
583
result = self._format.initialize(url)
584
basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
586
source_branch = self.open_branch()
587
source_repository = source_branch.repository
588
except errors.NotBranchError:
591
source_repository = self.open_repository()
592
except errors.NoRepositoryPresent:
593
# copy the entire basis one if there is one
594
# but there is no repository.
595
source_repository = basis_repo
600
result_repo = result.find_repository()
601
except errors.NoRepositoryPresent:
603
if source_repository is None and result_repo is not None:
605
elif source_repository is None and result_repo is None:
606
# no repo available, make a new one
607
result.create_repository()
608
elif source_repository is not None and result_repo is None:
609
# have source, and want to make a new target repo
610
# we don't clone the repo because that preserves attributes
611
# like is_shared(), and we have not yet implemented a
612
# repository sprout().
613
result_repo = result.create_repository()
614
if result_repo is not None:
615
# fetch needed content into target.
617
# XXX FIXME RBC 20060214 need tests for this when the basis
619
result_repo.fetch(basis_repo, revision_id=revision_id)
620
result_repo.fetch(source_repository, revision_id=revision_id)
621
if source_branch is not None:
622
source_branch.sprout(result, revision_id=revision_id)
624
result.create_branch()
625
# TODO: jam 20060426 we probably need a test in here in the
626
# case that the newly sprouted branch is a remote one
627
if result_repo is None or result_repo.make_working_trees():
628
result.create_workingtree()
632
class BzrDirPreSplitOut(BzrDir):
633
"""A common class for the all-in-one formats."""
635
def __init__(self, _transport, _format):
636
"""See BzrDir.__init__."""
637
super(BzrDirPreSplitOut, self).__init__(_transport, _format)
638
assert self._format._lock_class == TransportLock
639
assert self._format._lock_file_name == 'branch-lock'
640
self._control_files = LockableFiles(self.get_branch_transport(None),
641
self._format._lock_file_name,
642
self._format._lock_class)
644
def break_lock(self):
645
"""Pre-splitout bzrdirs do not suffer from stale locks."""
646
raise NotImplementedError(self.break_lock)
648
def clone(self, url, revision_id=None, basis=None, force_new_repo=False):
649
"""See BzrDir.clone()."""
650
from bzrlib.workingtree import WorkingTreeFormat2
652
result = self._format._initialize_for_clone(url)
653
basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
654
self.open_repository().clone(result, revision_id=revision_id, basis=basis_repo)
655
from_branch = self.open_branch()
656
from_branch.clone(result, revision_id=revision_id)
658
self.open_workingtree().clone(result, basis=basis_tree)
659
except errors.NotLocalUrl:
660
# make a new one, this format always has to have one.
662
WorkingTreeFormat2().initialize(result)
663
except errors.NotLocalUrl:
664
# but we cannot do it for remote trees.
665
to_branch = result.open_branch()
666
WorkingTreeFormat2().stub_initialize_remote(to_branch.control_files)
669
def create_branch(self):
670
"""See BzrDir.create_branch."""
671
return self.open_branch()
673
def create_repository(self, shared=False):
674
"""See BzrDir.create_repository."""
676
raise errors.IncompatibleFormat('shared repository', self._format)
677
return self.open_repository()
679
def create_workingtree(self, revision_id=None):
680
"""See BzrDir.create_workingtree."""
681
# this looks buggy but is not -really-
682
# clone and sprout will have set the revision_id
683
# and that will have set it for us, its only
684
# specific uses of create_workingtree in isolation
685
# that can do wonky stuff here, and that only
686
# happens for creating checkouts, which cannot be
687
# done on this format anyway. So - acceptable wart.
688
result = self.open_workingtree()
689
if revision_id is not None:
690
result.set_last_revision(revision_id)
693
def get_branch_transport(self, branch_format):
694
"""See BzrDir.get_branch_transport()."""
695
if branch_format is None:
696
return self.transport
698
branch_format.get_format_string()
699
except NotImplementedError:
700
return self.transport
701
raise errors.IncompatibleFormat(branch_format, self._format)
703
def get_repository_transport(self, repository_format):
704
"""See BzrDir.get_repository_transport()."""
705
if repository_format is None:
706
return self.transport
708
repository_format.get_format_string()
709
except NotImplementedError:
710
return self.transport
711
raise errors.IncompatibleFormat(repository_format, self._format)
713
def get_workingtree_transport(self, workingtree_format):
714
"""See BzrDir.get_workingtree_transport()."""
715
if workingtree_format is None:
716
return self.transport
718
workingtree_format.get_format_string()
719
except NotImplementedError:
720
return self.transport
721
raise errors.IncompatibleFormat(workingtree_format, self._format)
723
def needs_format_conversion(self, format=None):
724
"""See BzrDir.needs_format_conversion()."""
725
# if the format is not the same as the system default,
726
# an upgrade is needed.
728
format = BzrDirFormat.get_default_format()
729
return not isinstance(self._format, format.__class__)
731
def open_branch(self, unsupported=False):
732
"""See BzrDir.open_branch."""
733
from bzrlib.branch import BzrBranchFormat4
734
format = BzrBranchFormat4()
735
self._check_supported(format, unsupported)
736
return format.open(self, _found=True)
738
def sprout(self, url, revision_id=None, basis=None):
739
"""See BzrDir.sprout()."""
740
from bzrlib.workingtree import WorkingTreeFormat2
742
result = self._format._initialize_for_clone(url)
743
basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
745
self.open_repository().clone(result, revision_id=revision_id, basis=basis_repo)
746
except errors.NoRepositoryPresent:
749
self.open_branch().sprout(result, revision_id=revision_id)
750
except errors.NotBranchError:
752
# we always want a working tree
753
WorkingTreeFormat2().initialize(result)
757
class BzrDir4(BzrDirPreSplitOut):
758
"""A .bzr version 4 control object.
760
This is a deprecated format and may be removed after sept 2006.
763
def create_repository(self, shared=False):
764
"""See BzrDir.create_repository."""
765
return self._format.repository_format.initialize(self, shared)
767
def needs_format_conversion(self, format=None):
768
"""Format 4 dirs are always in need of conversion."""
771
def open_repository(self):
772
"""See BzrDir.open_repository."""
773
from bzrlib.repository import RepositoryFormat4
774
return RepositoryFormat4().open(self, _found=True)
777
class BzrDir5(BzrDirPreSplitOut):
778
"""A .bzr version 5 control object.
780
This is a deprecated format and may be removed after sept 2006.
783
def open_repository(self):
784
"""See BzrDir.open_repository."""
785
from bzrlib.repository import RepositoryFormat5
786
return RepositoryFormat5().open(self, _found=True)
788
def open_workingtree(self, _unsupported=False):
789
"""See BzrDir.create_workingtree."""
790
from bzrlib.workingtree import WorkingTreeFormat2
791
return WorkingTreeFormat2().open(self, _found=True)
794
class BzrDir6(BzrDirPreSplitOut):
795
"""A .bzr version 6 control object.
797
This is a deprecated format and may be removed after sept 2006.
800
def open_repository(self):
801
"""See BzrDir.open_repository."""
802
from bzrlib.repository import RepositoryFormat6
803
return RepositoryFormat6().open(self, _found=True)
805
def open_workingtree(self, _unsupported=False):
806
"""See BzrDir.create_workingtree."""
807
from bzrlib.workingtree import WorkingTreeFormat2
808
return WorkingTreeFormat2().open(self, _found=True)
811
class BzrDirMeta1(BzrDir):
812
"""A .bzr meta version 1 control object.
814
This is the first control object where the
815
individual aspects are really split out: there are separate repository,
816
workingtree and branch subdirectories and any subset of the three can be
817
present within a BzrDir.
820
def can_convert_format(self):
821
"""See BzrDir.can_convert_format()."""
824
def create_branch(self):
825
"""See BzrDir.create_branch."""
826
from bzrlib.branch import BranchFormat
827
return BranchFormat.get_default_format().initialize(self)
829
def create_repository(self, shared=False):
830
"""See BzrDir.create_repository."""
831
return self._format.repository_format.initialize(self, shared)
833
def create_workingtree(self, revision_id=None):
834
"""See BzrDir.create_workingtree."""
835
from bzrlib.workingtree import WorkingTreeFormat
836
return WorkingTreeFormat.get_default_format().initialize(self, revision_id)
838
def _get_mkdir_mode(self):
839
"""Figure out the mode to use when creating a bzrdir subdir."""
840
temp_control = LockableFiles(self.transport, '', TransportLock)
841
return temp_control._dir_mode
843
def get_branch_transport(self, branch_format):
844
"""See BzrDir.get_branch_transport()."""
845
if branch_format is None:
846
return self.transport.clone('branch')
848
branch_format.get_format_string()
849
except NotImplementedError:
850
raise errors.IncompatibleFormat(branch_format, self._format)
852
self.transport.mkdir('branch', mode=self._get_mkdir_mode())
853
except errors.FileExists:
855
return self.transport.clone('branch')
857
def get_repository_transport(self, repository_format):
858
"""See BzrDir.get_repository_transport()."""
859
if repository_format is None:
860
return self.transport.clone('repository')
862
repository_format.get_format_string()
863
except NotImplementedError:
864
raise errors.IncompatibleFormat(repository_format, self._format)
866
self.transport.mkdir('repository', mode=self._get_mkdir_mode())
867
except errors.FileExists:
869
return self.transport.clone('repository')
871
def get_workingtree_transport(self, workingtree_format):
872
"""See BzrDir.get_workingtree_transport()."""
873
if workingtree_format is None:
874
return self.transport.clone('checkout')
876
workingtree_format.get_format_string()
877
except NotImplementedError:
878
raise errors.IncompatibleFormat(workingtree_format, self._format)
880
self.transport.mkdir('checkout', mode=self._get_mkdir_mode())
881
except errors.FileExists:
883
return self.transport.clone('checkout')
885
def needs_format_conversion(self, format=None):
886
"""See BzrDir.needs_format_conversion()."""
888
format = BzrDirFormat.get_default_format()
889
if not isinstance(self._format, format.__class__):
890
# it is not a meta dir format, conversion is needed.
892
# we might want to push this down to the repository?
894
if not isinstance(self.open_repository()._format,
895
format.repository_format.__class__):
896
# the repository needs an upgrade.
898
except errors.NoRepositoryPresent:
900
# currently there are no other possible conversions for meta1 formats.
903
def open_branch(self, unsupported=False):
904
"""See BzrDir.open_branch."""
905
from bzrlib.branch import BranchFormat
906
format = BranchFormat.find_format(self)
907
self._check_supported(format, unsupported)
908
return format.open(self, _found=True)
910
def open_repository(self, unsupported=False):
911
"""See BzrDir.open_repository."""
912
from bzrlib.repository import RepositoryFormat
913
format = RepositoryFormat.find_format(self)
914
self._check_supported(format, unsupported)
915
return format.open(self, _found=True)
917
def open_workingtree(self, unsupported=False):
918
"""See BzrDir.open_workingtree."""
919
from bzrlib.workingtree import WorkingTreeFormat
920
format = WorkingTreeFormat.find_format(self)
921
self._check_supported(format, unsupported)
922
return format.open(self, _found=True)
925
class BzrDirFormat(object):
926
"""An encapsulation of the initialization and open routines for a format.
928
Formats provide three things:
929
* An initialization routine,
933
Formats are placed in an dict by their format string for reference
934
during bzrdir opening. These should be subclasses of BzrDirFormat
937
Once a format is deprecated, just deprecate the initialize and open
938
methods on the format class. Do not deprecate the object, as the
939
object will be created every system load.
942
_default_format = None
943
"""The default format used for new .bzr dirs."""
946
"""The known formats."""
948
_control_formats = []
949
"""The registered control formats - .bzr, ....
951
This is a list of BzrDirFormat objects.
954
_lock_file_name = 'branch-lock'
956
# _lock_class must be set in subclasses to the lock type, typ.
957
# TransportLock or LockDir
960
def find_format(klass, transport):
961
"""Return the format present at transport."""
962
for format in klass._control_formats:
964
return format.probe_transport(transport)
965
except errors.NotBranchError:
966
# this format does not find a control dir here.
968
raise errors.NotBranchError(path=transport.base)
971
def probe_transport(klass, transport):
972
"""Return the .bzrdir style transport present at URL."""
974
format_string = transport.get(".bzr/branch-format").read()
975
except errors.NoSuchFile:
976
raise errors.NotBranchError(path=transport.base)
979
return klass._formats[format_string]
981
raise errors.UnknownFormatError(format_string)
984
def get_default_format(klass):
985
"""Return the current default format."""
986
return klass._default_format
988
def get_format_string(self):
989
"""Return the ASCII format string that identifies this format."""
990
raise NotImplementedError(self.get_format_string)
992
def get_format_description(self):
993
"""Return the short description for this format."""
994
raise NotImplementedError(self.get_format_description)
996
def get_converter(self, format=None):
997
"""Return the converter to use to convert bzrdirs needing converts.
999
This returns a bzrlib.bzrdir.Converter object.
1001
This should return the best upgrader to step this format towards the
1002
current default format. In the case of plugins we can/should provide
1003
some means for them to extend the range of returnable converters.
1005
:param format: Optional format to override the default format of the
1008
raise NotImplementedError(self.get_converter)
1010
def initialize(self, url):
1011
"""Create a bzr control dir at this url and return an opened copy.
1013
Subclasses should typically override initialize_on_transport
1014
instead of this method.
1016
return self.initialize_on_transport(get_transport(url))
1018
def initialize_on_transport(self, transport):
1019
"""Initialize a new bzrdir in the base directory of a Transport."""
1020
# Since we don't have a .bzr directory, inherit the
1021
# mode from the root directory
1022
temp_control = LockableFiles(transport, '', TransportLock)
1023
temp_control._transport.mkdir('.bzr',
1024
# FIXME: RBC 20060121 don't peek under
1026
mode=temp_control._dir_mode)
1027
file_mode = temp_control._file_mode
1029
mutter('created control directory in ' + transport.base)
1030
control = transport.clone('.bzr')
1031
utf8_files = [('README',
1032
"This is a Bazaar-NG control directory.\n"
1033
"Do not change any files in this directory.\n"),
1034
('branch-format', self.get_format_string()),
1036
# NB: no need to escape relative paths that are url safe.
1037
control_files = LockableFiles(control, self._lock_file_name,
1039
control_files.create_lock()
1040
control_files.lock_write()
1042
for file, content in utf8_files:
1043
control_files.put_utf8(file, content)
1045
control_files.unlock()
1046
return self.open(transport, _found=True)
1048
def is_supported(self):
1049
"""Is this format supported?
1051
Supported formats must be initializable and openable.
1052
Unsupported formats may not support initialization or committing or
1053
some other features depending on the reason for not being supported.
1058
def known_formats(klass):
1059
"""Return all the known formats.
1061
Concrete formats should override _known_formats.
1063
# There is double indirection here to make sure that control
1064
# formats used by more than one dir format will only be probed
1065
# once. This can otherwise be quite expensive for remote connections.
1067
for format in klass._control_formats:
1068
result.update(format._known_formats())
1072
def _known_formats(klass):
1073
"""Return the known format instances for this control format."""
1074
return set(klass._formats.values())
1076
def open(self, transport, _found=False):
1077
"""Return an instance of this format for the dir transport points at.
1079
_found is a private parameter, do not use it.
1082
assert isinstance(BzrDirFormat.find_format(transport),
1084
return self._open(transport)
1086
def _open(self, transport):
1087
"""Template method helper for opening BzrDirectories.
1089
This performs the actual open and any additional logic or parameter
1092
raise NotImplementedError(self._open)
1095
def register_format(klass, format):
1096
klass._formats[format.get_format_string()] = format
1099
def register_control_format(klass, format):
1100
"""Register a format that does not use '.bzrdir' for its control dir.
1102
TODO: This should be pulled up into a 'ControlDirFormat' base class
1103
which BzrDirFormat can inherit from, and renamed to register_format
1104
there. It has been done without that for now for simplicity of
1107
klass._control_formats.append(format)
1110
def set_default_format(klass, format):
1111
klass._default_format = format
1114
return self.get_format_string()[:-1]
1117
def unregister_format(klass, format):
1118
assert klass._formats[format.get_format_string()] is format
1119
del klass._formats[format.get_format_string()]
1122
def unregister_control_format(klass, format):
1123
klass._control_formats.remove(format)
1126
# register BzrDirFormat as a control format
1127
BzrDirFormat.register_control_format(BzrDirFormat)
1130
class BzrDirFormat4(BzrDirFormat):
1131
"""Bzr dir format 4.
1133
This format is a combined format for working tree, branch and repository.
1135
- Format 1 working trees [always]
1136
- Format 4 branches [always]
1137
- Format 4 repositories [always]
1139
This format is deprecated: it indexes texts using a text it which is
1140
removed in format 5; write support for this format has been removed.
1143
_lock_class = TransportLock
1145
def get_format_string(self):
1146
"""See BzrDirFormat.get_format_string()."""
1147
return "Bazaar-NG branch, format 0.0.4\n"
1149
def get_format_description(self):
1150
"""See BzrDirFormat.get_format_description()."""
1151
return "All-in-one format 4"
1153
def get_converter(self, format=None):
1154
"""See BzrDirFormat.get_converter()."""
1155
# there is one and only one upgrade path here.
1156
return ConvertBzrDir4To5()
1158
def initialize_on_transport(self, transport):
1159
"""Format 4 branches cannot be created."""
1160
raise errors.UninitializableFormat(self)
1162
def is_supported(self):
1163
"""Format 4 is not supported.
1165
It is not supported because the model changed from 4 to 5 and the
1166
conversion logic is expensive - so doing it on the fly was not
1171
def _open(self, transport):
1172
"""See BzrDirFormat._open."""
1173
return BzrDir4(transport, self)
1175
def __return_repository_format(self):
1176
"""Circular import protection."""
1177
from bzrlib.repository import RepositoryFormat4
1178
return RepositoryFormat4(self)
1179
repository_format = property(__return_repository_format)
1182
class BzrDirFormat5(BzrDirFormat):
1183
"""Bzr control format 5.
1185
This format is a combined format for working tree, branch and repository.
1187
- Format 2 working trees [always]
1188
- Format 4 branches [always]
1189
- Format 5 repositories [always]
1190
Unhashed stores in the repository.
1193
_lock_class = TransportLock
1195
def get_format_string(self):
1196
"""See BzrDirFormat.get_format_string()."""
1197
return "Bazaar-NG branch, format 5\n"
1199
def get_format_description(self):
1200
"""See BzrDirFormat.get_format_description()."""
1201
return "All-in-one format 5"
1203
def get_converter(self, format=None):
1204
"""See BzrDirFormat.get_converter()."""
1205
# there is one and only one upgrade path here.
1206
return ConvertBzrDir5To6()
1208
def _initialize_for_clone(self, url):
1209
return self.initialize_on_transport(get_transport(url), _cloning=True)
1211
def initialize_on_transport(self, transport, _cloning=False):
1212
"""Format 5 dirs always have working tree, branch and repository.
1214
Except when they are being cloned.
1216
from bzrlib.branch import BzrBranchFormat4
1217
from bzrlib.repository import RepositoryFormat5
1218
from bzrlib.workingtree import WorkingTreeFormat2
1219
result = (super(BzrDirFormat5, self).initialize_on_transport(transport))
1220
RepositoryFormat5().initialize(result, _internal=True)
1222
BzrBranchFormat4().initialize(result)
1223
WorkingTreeFormat2().initialize(result)
1226
def _open(self, transport):
1227
"""See BzrDirFormat._open."""
1228
return BzrDir5(transport, self)
1230
def __return_repository_format(self):
1231
"""Circular import protection."""
1232
from bzrlib.repository import RepositoryFormat5
1233
return RepositoryFormat5(self)
1234
repository_format = property(__return_repository_format)
1237
class BzrDirFormat6(BzrDirFormat):
1238
"""Bzr control format 6.
1240
This format is a combined format for working tree, branch and repository.
1242
- Format 2 working trees [always]
1243
- Format 4 branches [always]
1244
- Format 6 repositories [always]
1247
_lock_class = TransportLock
1249
def get_format_string(self):
1250
"""See BzrDirFormat.get_format_string()."""
1251
return "Bazaar-NG branch, format 6\n"
1253
def get_format_description(self):
1254
"""See BzrDirFormat.get_format_description()."""
1255
return "All-in-one format 6"
1257
def get_converter(self, format=None):
1258
"""See BzrDirFormat.get_converter()."""
1259
# there is one and only one upgrade path here.
1260
return ConvertBzrDir6ToMeta()
1262
def _initialize_for_clone(self, url):
1263
return self.initialize_on_transport(get_transport(url), _cloning=True)
1265
def initialize_on_transport(self, transport, _cloning=False):
1266
"""Format 6 dirs always have working tree, branch and repository.
1268
Except when they are being cloned.
1270
from bzrlib.branch import BzrBranchFormat4
1271
from bzrlib.repository import RepositoryFormat6
1272
from bzrlib.workingtree import WorkingTreeFormat2
1273
result = super(BzrDirFormat6, self).initialize_on_transport(transport)
1274
RepositoryFormat6().initialize(result, _internal=True)
1276
BzrBranchFormat4().initialize(result)
1278
WorkingTreeFormat2().initialize(result)
1279
except errors.NotLocalUrl:
1280
# emulate pre-check behaviour for working tree and silently
1285
def _open(self, transport):
1286
"""See BzrDirFormat._open."""
1287
return BzrDir6(transport, self)
1289
def __return_repository_format(self):
1290
"""Circular import protection."""
1291
from bzrlib.repository import RepositoryFormat6
1292
return RepositoryFormat6(self)
1293
repository_format = property(__return_repository_format)
1296
class BzrDirMetaFormat1(BzrDirFormat):
1297
"""Bzr meta control format 1
1299
This is the first format with split out working tree, branch and repository
1302
- Format 3 working trees [optional]
1303
- Format 5 branches [optional]
1304
- Format 7 repositories [optional]
1307
_lock_class = LockDir
1309
def get_converter(self, format=None):
1310
"""See BzrDirFormat.get_converter()."""
1312
format = BzrDirFormat.get_default_format()
1313
if not isinstance(self, format.__class__):
1314
# converting away from metadir is not implemented
1315
raise NotImplementedError(self.get_converter)
1316
return ConvertMetaToMeta(format)
1318
def get_format_string(self):
1319
"""See BzrDirFormat.get_format_string()."""
1320
return "Bazaar-NG meta directory, format 1\n"
1322
def get_format_description(self):
1323
"""See BzrDirFormat.get_format_description()."""
1324
return "Meta directory format 1"
1326
def _open(self, transport):
1327
"""See BzrDirFormat._open."""
1328
return BzrDirMeta1(transport, self)
1330
def __return_repository_format(self):
1331
"""Circular import protection."""
1332
if getattr(self, '_repository_format', None):
1333
return self._repository_format
1334
from bzrlib.repository import RepositoryFormat
1335
return RepositoryFormat.get_default_format()
1337
def __set_repository_format(self, value):
1338
"""Allow changint the repository format for metadir formats."""
1339
self._repository_format = value
1341
repository_format = property(__return_repository_format, __set_repository_format)
1344
BzrDirFormat.register_format(BzrDirFormat4())
1345
BzrDirFormat.register_format(BzrDirFormat5())
1346
BzrDirFormat.register_format(BzrDirFormat6())
1347
__default_format = BzrDirMetaFormat1()
1348
BzrDirFormat.register_format(__default_format)
1349
BzrDirFormat.set_default_format(__default_format)
1352
class BzrDirTestProviderAdapter(object):
1353
"""A tool to generate a suite testing multiple bzrdir formats at once.
1355
This is done by copying the test once for each transport and injecting
1356
the transport_server, transport_readonly_server, and bzrdir_format
1357
classes into each copy. Each copy is also given a new id() to make it
1361
def __init__(self, transport_server, transport_readonly_server, formats):
1362
self._transport_server = transport_server
1363
self._transport_readonly_server = transport_readonly_server
1364
self._formats = formats
1366
def adapt(self, test):
1367
result = TestSuite()
1368
for format in self._formats:
1369
new_test = deepcopy(test)
1370
new_test.transport_server = self._transport_server
1371
new_test.transport_readonly_server = self._transport_readonly_server
1372
new_test.bzrdir_format = format
1373
def make_new_test_id():
1374
new_id = "%s(%s)" % (new_test.id(), format.__class__.__name__)
1375
return lambda: new_id
1376
new_test.id = make_new_test_id()
1377
result.addTest(new_test)
1381
class ScratchDir(BzrDir6):
1382
"""Special test class: a bzrdir that cleans up itself..
1384
>>> d = ScratchDir()
1385
>>> base = d.transport.base
1388
>>> b.transport.__del__()
1393
def __init__(self, files=[], dirs=[], transport=None):
1394
"""Make a test branch.
1396
This creates a temporary directory and runs init-tree in it.
1398
If any files are listed, they are created in the working copy.
1400
if transport is None:
1401
transport = bzrlib.transport.local.ScratchTransport()
1402
# local import for scope restriction
1403
BzrDirFormat6().initialize(transport.base)
1404
super(ScratchDir, self).__init__(transport, BzrDirFormat6())
1405
self.create_repository()
1406
self.create_branch()
1407
self.create_workingtree()
1409
super(ScratchDir, self).__init__(transport, BzrDirFormat6())
1411
# BzrBranch creates a clone to .bzr and then forgets about the
1412
# original transport. A ScratchTransport() deletes itself and
1413
# everything underneath it when it goes away, so we need to
1414
# grab a local copy to prevent that from happening
1415
self._transport = transport
1418
self._transport.mkdir(d)
1421
self._transport.put(f, 'content of %s' % f)
1425
>>> orig = ScratchDir(files=["file1", "file2"])
1426
>>> os.listdir(orig.base)
1427
[u'.bzr', u'file1', u'file2']
1428
>>> clone = orig.clone()
1429
>>> if os.name != 'nt':
1430
... os.path.samefile(orig.base, clone.base)
1432
... orig.base == clone.base
1435
>>> os.listdir(clone.base)
1436
[u'.bzr', u'file1', u'file2']
1438
from shutil import copytree
1439
from bzrlib.osutils import mkdtemp
1442
copytree(self.base, base, symlinks=True)
1444
transport=bzrlib.transport.local.ScratchTransport(base))
1447
class Converter(object):
1448
"""Converts a disk format object from one format to another."""
1450
def convert(self, to_convert, pb):
1451
"""Perform the conversion of to_convert, giving feedback via pb.
1453
:param to_convert: The disk object to convert.
1454
:param pb: a progress bar to use for progress information.
1457
def step(self, message):
1458
"""Update the pb by a step."""
1460
self.pb.update(message, self.count, self.total)
1463
class ConvertBzrDir4To5(Converter):
1464
"""Converts format 4 bzr dirs to format 5."""
1467
super(ConvertBzrDir4To5, self).__init__()
1468
self.converted_revs = set()
1469
self.absent_revisions = set()
1473
def convert(self, to_convert, pb):
1474
"""See Converter.convert()."""
1475
self.bzrdir = to_convert
1477
self.pb.note('starting upgrade from format 4 to 5')
1478
if isinstance(self.bzrdir.transport, LocalTransport):
1479
self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
1480
self._convert_to_weaves()
1481
return BzrDir.open(self.bzrdir.root_transport.base)
1483
def _convert_to_weaves(self):
1484
self.pb.note('note: upgrade may be faster if all store files are ungzipped first')
1487
stat = self.bzrdir.transport.stat('weaves')
1488
if not S_ISDIR(stat.st_mode):
1489
self.bzrdir.transport.delete('weaves')
1490
self.bzrdir.transport.mkdir('weaves')
1491
except errors.NoSuchFile:
1492
self.bzrdir.transport.mkdir('weaves')
1493
# deliberately not a WeaveFile as we want to build it up slowly.
1494
self.inv_weave = Weave('inventory')
1495
# holds in-memory weaves for all files
1496
self.text_weaves = {}
1497
self.bzrdir.transport.delete('branch-format')
1498
self.branch = self.bzrdir.open_branch()
1499
self._convert_working_inv()
1500
rev_history = self.branch.revision_history()
1501
# to_read is a stack holding the revisions we still need to process;
1502
# appending to it adds new highest-priority revisions
1503
self.known_revisions = set(rev_history)
1504
self.to_read = rev_history[-1:]
1506
rev_id = self.to_read.pop()
1507
if (rev_id not in self.revisions
1508
and rev_id not in self.absent_revisions):
1509
self._load_one_rev(rev_id)
1511
to_import = self._make_order()
1512
for i, rev_id in enumerate(to_import):
1513
self.pb.update('converting revision', i, len(to_import))
1514
self._convert_one_rev(rev_id)
1516
self._write_all_weaves()
1517
self._write_all_revs()
1518
self.pb.note('upgraded to weaves:')
1519
self.pb.note(' %6d revisions and inventories', len(self.revisions))
1520
self.pb.note(' %6d revisions not present', len(self.absent_revisions))
1521
self.pb.note(' %6d texts', self.text_count)
1522
self._cleanup_spare_files_after_format4()
1523
self.branch.control_files.put_utf8('branch-format', BzrDirFormat5().get_format_string())
1525
def _cleanup_spare_files_after_format4(self):
1526
# FIXME working tree upgrade foo.
1527
for n in 'merged-patches', 'pending-merged-patches':
1529
## assert os.path.getsize(p) == 0
1530
self.bzrdir.transport.delete(n)
1531
except errors.NoSuchFile:
1533
self.bzrdir.transport.delete_tree('inventory-store')
1534
self.bzrdir.transport.delete_tree('text-store')
1536
def _convert_working_inv(self):
1537
inv = serializer_v4.read_inventory(self.branch.control_files.get('inventory'))
1538
new_inv_xml = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)
1539
# FIXME inventory is a working tree change.
1540
self.branch.control_files.put('inventory', new_inv_xml)
1542
def _write_all_weaves(self):
1543
controlweaves = WeaveStore(self.bzrdir.transport, prefixed=False)
1544
weave_transport = self.bzrdir.transport.clone('weaves')
1545
weaves = WeaveStore(weave_transport, prefixed=False)
1546
transaction = WriteTransaction()
1550
for file_id, file_weave in self.text_weaves.items():
1551
self.pb.update('writing weave', i, len(self.text_weaves))
1552
weaves._put_weave(file_id, file_weave, transaction)
1554
self.pb.update('inventory', 0, 1)
1555
controlweaves._put_weave('inventory', self.inv_weave, transaction)
1556
self.pb.update('inventory', 1, 1)
1560
def _write_all_revs(self):
1561
"""Write all revisions out in new form."""
1562
self.bzrdir.transport.delete_tree('revision-store')
1563
self.bzrdir.transport.mkdir('revision-store')
1564
revision_transport = self.bzrdir.transport.clone('revision-store')
1566
_revision_store = TextRevisionStore(TextStore(revision_transport,
1570
transaction = bzrlib.transactions.WriteTransaction()
1571
for i, rev_id in enumerate(self.converted_revs):
1572
self.pb.update('write revision', i, len(self.converted_revs))
1573
_revision_store.add_revision(self.revisions[rev_id], transaction)
1577
def _load_one_rev(self, rev_id):
1578
"""Load a revision object into memory.
1580
Any parents not either loaded or abandoned get queued to be
1582
self.pb.update('loading revision',
1583
len(self.revisions),
1584
len(self.known_revisions))
1585
if not self.branch.repository.has_revision(rev_id):
1587
self.pb.note('revision {%s} not present in branch; '
1588
'will be converted as a ghost',
1590
self.absent_revisions.add(rev_id)
1592
rev = self.branch.repository._revision_store.get_revision(rev_id,
1593
self.branch.repository.get_transaction())
1594
for parent_id in rev.parent_ids:
1595
self.known_revisions.add(parent_id)
1596
self.to_read.append(parent_id)
1597
self.revisions[rev_id] = rev
1599
def _load_old_inventory(self, rev_id):
1600
assert rev_id not in self.converted_revs
1601
old_inv_xml = self.branch.repository.inventory_store.get(rev_id).read()
1602
inv = serializer_v4.read_inventory_from_string(old_inv_xml)
1603
rev = self.revisions[rev_id]
1604
if rev.inventory_sha1:
1605
assert rev.inventory_sha1 == sha_string(old_inv_xml), \
1606
'inventory sha mismatch for {%s}' % rev_id
1609
def _load_updated_inventory(self, rev_id):
1610
assert rev_id in self.converted_revs
1611
inv_xml = self.inv_weave.get_text(rev_id)
1612
inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(inv_xml)
1615
def _convert_one_rev(self, rev_id):
1616
"""Convert revision and all referenced objects to new format."""
1617
rev = self.revisions[rev_id]
1618
inv = self._load_old_inventory(rev_id)
1619
present_parents = [p for p in rev.parent_ids
1620
if p not in self.absent_revisions]
1621
self._convert_revision_contents(rev, inv, present_parents)
1622
self._store_new_weave(rev, inv, present_parents)
1623
self.converted_revs.add(rev_id)
1625
def _store_new_weave(self, rev, inv, present_parents):
1626
# the XML is now updated with text versions
1630
if ie.kind == 'root_directory':
1632
assert hasattr(ie, 'revision'), \
1633
'no revision on {%s} in {%s}' % \
1634
(file_id, rev.revision_id)
1635
new_inv_xml = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)
1636
new_inv_sha1 = sha_string(new_inv_xml)
1637
self.inv_weave.add_lines(rev.revision_id,
1639
new_inv_xml.splitlines(True))
1640
rev.inventory_sha1 = new_inv_sha1
1642
def _convert_revision_contents(self, rev, inv, present_parents):
1643
"""Convert all the files within a revision.
1645
Also upgrade the inventory to refer to the text revision ids."""
1646
rev_id = rev.revision_id
1647
mutter('converting texts of revision {%s}',
1649
parent_invs = map(self._load_updated_inventory, present_parents)
1652
self._convert_file_version(rev, ie, parent_invs)
1654
def _convert_file_version(self, rev, ie, parent_invs):
1655
"""Convert one version of one file.
1657
The file needs to be added into the weave if it is a merge
1658
of >=2 parents or if it's changed from its parent.
1660
if ie.kind == 'root_directory':
1662
file_id = ie.file_id
1663
rev_id = rev.revision_id
1664
w = self.text_weaves.get(file_id)
1667
self.text_weaves[file_id] = w
1668
text_changed = False
1669
previous_entries = ie.find_previous_heads(parent_invs,
1673
for old_revision in previous_entries:
1674
# if this fails, its a ghost ?
1675
assert old_revision in self.converted_revs
1676
self.snapshot_ie(previous_entries, ie, w, rev_id)
1678
assert getattr(ie, 'revision', None) is not None
1680
def snapshot_ie(self, previous_revisions, ie, w, rev_id):
1681
# TODO: convert this logic, which is ~= snapshot to
1682
# a call to:. This needs the path figured out. rather than a work_tree
1683
# a v4 revision_tree can be given, or something that looks enough like
1684
# one to give the file content to the entry if it needs it.
1685
# and we need something that looks like a weave store for snapshot to
1687
#ie.snapshot(rev, PATH, previous_revisions, REVISION_TREE, InMemoryWeaveStore(self.text_weaves))
1688
if len(previous_revisions) == 1:
1689
previous_ie = previous_revisions.values()[0]
1690
if ie._unchanged(previous_ie):
1691
ie.revision = previous_ie.revision
1694
text = self.branch.repository.text_store.get(ie.text_id)
1695
file_lines = text.readlines()
1696
assert sha_strings(file_lines) == ie.text_sha1
1697
assert sum(map(len, file_lines)) == ie.text_size
1698
w.add_lines(rev_id, previous_revisions, file_lines)
1699
self.text_count += 1
1701
w.add_lines(rev_id, previous_revisions, [])
1702
ie.revision = rev_id
1704
def _make_order(self):
1705
"""Return a suitable order for importing revisions.
1707
The order must be such that an revision is imported after all
1708
its (present) parents.
1710
todo = set(self.revisions.keys())
1711
done = self.absent_revisions.copy()
1714
# scan through looking for a revision whose parents
1716
for rev_id in sorted(list(todo)):
1717
rev = self.revisions[rev_id]
1718
parent_ids = set(rev.parent_ids)
1719
if parent_ids.issubset(done):
1720
# can take this one now
1721
order.append(rev_id)
1727
class ConvertBzrDir5To6(Converter):
1728
"""Converts format 5 bzr dirs to format 6."""
1730
def convert(self, to_convert, pb):
1731
"""See Converter.convert()."""
1732
self.bzrdir = to_convert
1734
self.pb.note('starting upgrade from format 5 to 6')
1735
self._convert_to_prefixed()
1736
return BzrDir.open(self.bzrdir.root_transport.base)
1738
def _convert_to_prefixed(self):
1739
from bzrlib.store import TransportStore
1740
self.bzrdir.transport.delete('branch-format')
1741
for store_name in ["weaves", "revision-store"]:
1742
self.pb.note("adding prefixes to %s" % store_name)
1743
store_transport = self.bzrdir.transport.clone(store_name)
1744
store = TransportStore(store_transport, prefixed=True)
1745
for urlfilename in store_transport.list_dir('.'):
1746
filename = urlutils.unescape(urlfilename)
1747
if (filename.endswith(".weave") or
1748
filename.endswith(".gz") or
1749
filename.endswith(".sig")):
1750
file_id = os.path.splitext(filename)[0]
1753
prefix_dir = store.hash_prefix(file_id)
1754
# FIXME keep track of the dirs made RBC 20060121
1756
store_transport.move(filename, prefix_dir + '/' + filename)
1757
except errors.NoSuchFile: # catches missing dirs strangely enough
1758
store_transport.mkdir(prefix_dir)
1759
store_transport.move(filename, prefix_dir + '/' + filename)
1760
self.bzrdir._control_files.put_utf8('branch-format', BzrDirFormat6().get_format_string())
1763
class ConvertBzrDir6ToMeta(Converter):
1764
"""Converts format 6 bzr dirs to metadirs."""
1766
def convert(self, to_convert, pb):
1767
"""See Converter.convert()."""
1768
self.bzrdir = to_convert
1771
self.total = 20 # the steps we know about
1772
self.garbage_inventories = []
1774
self.pb.note('starting upgrade from format 6 to metadir')
1775
self.bzrdir._control_files.put_utf8('branch-format', "Converting to format 6")
1776
# its faster to move specific files around than to open and use the apis...
1777
# first off, nuke ancestry.weave, it was never used.
1779
self.step('Removing ancestry.weave')
1780
self.bzrdir.transport.delete('ancestry.weave')
1781
except errors.NoSuchFile:
1783
# find out whats there
1784
self.step('Finding branch files')
1785
last_revision = self.bzrdir.open_branch().last_revision()
1786
bzrcontents = self.bzrdir.transport.list_dir('.')
1787
for name in bzrcontents:
1788
if name.startswith('basis-inventory.'):
1789
self.garbage_inventories.append(name)
1790
# create new directories for repository, working tree and branch
1791
self.dir_mode = self.bzrdir._control_files._dir_mode
1792
self.file_mode = self.bzrdir._control_files._file_mode
1793
repository_names = [('inventory.weave', True),
1794
('revision-store', True),
1796
self.step('Upgrading repository ')
1797
self.bzrdir.transport.mkdir('repository', mode=self.dir_mode)
1798
self.make_lock('repository')
1799
# we hard code the formats here because we are converting into
1800
# the meta format. The meta format upgrader can take this to a
1801
# future format within each component.
1802
self.put_format('repository', bzrlib.repository.RepositoryFormat7())
1803
for entry in repository_names:
1804
self.move_entry('repository', entry)
1806
self.step('Upgrading branch ')
1807
self.bzrdir.transport.mkdir('branch', mode=self.dir_mode)
1808
self.make_lock('branch')
1809
self.put_format('branch', bzrlib.branch.BzrBranchFormat5())
1810
branch_files = [('revision-history', True),
1811
('branch-name', True),
1813
for entry in branch_files:
1814
self.move_entry('branch', entry)
1816
self.step('Upgrading working tree')
1817
self.bzrdir.transport.mkdir('checkout', mode=self.dir_mode)
1818
self.make_lock('checkout')
1819
self.put_format('checkout', bzrlib.workingtree.WorkingTreeFormat3())
1820
self.bzrdir.transport.delete_multi(self.garbage_inventories, self.pb)
1821
checkout_files = [('pending-merges', True),
1822
('inventory', True),
1823
('stat-cache', False)]
1824
for entry in checkout_files:
1825
self.move_entry('checkout', entry)
1826
if last_revision is not None:
1827
self.bzrdir._control_files.put_utf8('checkout/last-revision',
1829
self.bzrdir._control_files.put_utf8('branch-format', BzrDirMetaFormat1().get_format_string())
1830
return BzrDir.open(self.bzrdir.root_transport.base)
1832
def make_lock(self, name):
1833
"""Make a lock for the new control dir name."""
1834
self.step('Make %s lock' % name)
1835
ld = LockDir(self.bzrdir.transport,
1837
file_modebits=self.file_mode,
1838
dir_modebits=self.dir_mode)
1841
def move_entry(self, new_dir, entry):
1842
"""Move then entry name into new_dir."""
1844
mandatory = entry[1]
1845
self.step('Moving %s' % name)
1847
self.bzrdir.transport.move(name, '%s/%s' % (new_dir, name))
1848
except errors.NoSuchFile:
1852
def put_format(self, dirname, format):
1853
self.bzrdir._control_files.put_utf8('%s/format' % dirname, format.get_format_string())
1856
class ConvertMetaToMeta(Converter):
1857
"""Converts the components of metadirs."""
1859
def __init__(self, target_format):
1860
"""Create a metadir to metadir converter.
1862
:param target_format: The final metadir format that is desired.
1864
self.target_format = target_format
1866
def convert(self, to_convert, pb):
1867
"""See Converter.convert()."""
1868
self.bzrdir = to_convert
1872
self.step('checking repository format')
1874
repo = self.bzrdir.open_repository()
1875
except errors.NoRepositoryPresent:
1878
if not isinstance(repo._format, self.target_format.repository_format.__class__):
1879
from bzrlib.repository import CopyConverter
1880
self.pb.note('starting repository conversion')
1881
converter = CopyConverter(self.target_format.repository_format)
1882
converter.convert(repo, pb)
added
removed
bzrlib/bzrdir.py
