« back to all changes in this revision
Viewing changes to bzrlib/bzrdir.py
- browse files at revision 1185.85.84
- compare with another revision
- compare with revision 331
- download diff
- download tarball
- view history from revision 1185.85.84
- Committer: John Arbash Meinel
- Date: 2006-03-08 14:31:23 UTC
- mfrom: (1598 +trunk)
- mto: (1685.1.1 bzr-encoding)
- mto: This revision was merged to the branch mainline in revision 1752.
- Revision ID: john@arbash-meinel.com-20060308143123-448308b0db4de410
[merge] bzr.dev 1573, lots of updates
- files added:
- bzrlib/bzrdir.py
- bzrlib/store/revision
- bzrlib/store/versioned
- bzrlib/tests/bzrdir_implementations
- bzrlib/tests/interrepository_implementations
- bzrlib/tests/interversionedfile_implementations
- bzrlib/tests/repository_implementations
- bzrlib/tests/revisionstore_implementations
- bzrlib/tests/workingtree_implementations
- files removed:
- bzrlib/_changeset.py
- patches
- files renamed:
- bzrlib/store/weave.py => bzrlib/store/versioned/__init__.py
- bzrlib/tests/test_parent.py => bzrlib/tests/branch_implementations/test_parent.py
- bzrlib/tests/test_fileid_involved.py => bzrlib/tests/repository_implementations/test_fileid_involved.py
- files modified:
- BRANCH.TODO
added
removed
bzrlib/bzrdir.py
1
# Copyright (C) 2005, 2006 Canonical Ltd
2
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.
7
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.
12
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
16
17
"""BzrDir logic. The BzrDir is the basic control directory used by bzr.
18
19
At format 7 this was split out into Branch, Repository and Checkout control
20
directories.
21
"""
22
23
from copy import deepcopy
24
import os
25
from cStringIO import StringIO
26
from unittest import TestSuite
27
28
import bzrlib
29
import bzrlib.errors as errors
30
from bzrlib.lockable_files import LockableFiles, TransportLock
31
from bzrlib.osutils import safe_unicode
32
from bzrlib.osutils import (
33
abspath,
34
pathjoin,
35
safe_unicode,
36
sha_strings,
37
sha_string,
38
)
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
from bzrlib.weave import Weave
48
from bzrlib.xml4 import serializer_v4
49
from bzrlib.xml5 import serializer_v5
50
51
52
class BzrDir(object):
53
"""A .bzr control diretory.
54
55
BzrDir instances let you create or open any of the things that can be
56
found within .bzr - checkouts, branches and repositories.
57
58
transport
59
the transport which this bzr dir is rooted at (i.e. file:///.../.bzr/)
60
root_transport
61
a transport connected to the directory this bzr was opened from.
62
"""
63
64
def can_convert_format(self):
65
"""Return true if this bzrdir is one whose format we can convert from."""
66
return True
67
68
def _check_supported(self, format, allow_unsupported):
69
"""Check whether format is a supported format.
70
71
If allow_unsupported is True, this is a no-op.
72
"""
73
if not allow_unsupported and not format.is_supported():
74
raise errors.UnsupportedFormatError(format)
75
76
def clone(self, url, revision_id=None, basis=None, force_new_repo=False):
77
"""Clone this bzrdir and its contents to url verbatim.
78
79
If urls last component does not exist, it will be created.
80
81
if revision_id is not None, then the clone operation may tune
82
itself to download less data.
83
:param force_new_repo: Do not use a shared repository for the target
84
even if one is available.
85
"""
86
self._make_tail(url)
87
basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
88
result = self._format.initialize(url)
89
try:
90
local_repo = self.find_repository()
91
except errors.NoRepositoryPresent:
92
local_repo = None
93
if local_repo:
94
# may need to copy content in
95
if force_new_repo:
96
local_repo.clone(result, revision_id=revision_id, basis=basis_repo)
97
else:
98
try:
99
result_repo = result.find_repository()
100
# fetch content this dir needs.
101
if basis_repo:
102
# XXX FIXME RBC 20060214 need tests for this when the basis
103
# is incomplete
104
result_repo.fetch(basis_repo, revision_id=revision_id)
105
result_repo.fetch(local_repo, revision_id=revision_id)
106
except errors.NoRepositoryPresent:
107
# needed to make one anyway.
108
local_repo.clone(result, revision_id=revision_id, basis=basis_repo)
109
# 1 if there is a branch present
110
# make sure its content is available in the target repository
111
# clone it.
112
try:
113
self.open_branch().clone(result, revision_id=revision_id)
114
except errors.NotBranchError:
115
pass
116
try:
117
self.open_workingtree().clone(result, basis=basis_tree)
118
except (errors.NoWorkingTree, errors.NotLocalUrl):
119
pass
120
return result
121
122
def _get_basis_components(self, basis):
123
"""Retrieve the basis components that are available at basis."""
124
if basis is None:
125
return None, None, None
126
try:
127
basis_tree = basis.open_workingtree()
128
basis_branch = basis_tree.branch
129
basis_repo = basis_branch.repository
130
except (errors.NoWorkingTree, errors.NotLocalUrl):
131
basis_tree = None
132
try:
133
basis_branch = basis.open_branch()
134
basis_repo = basis_branch.repository
135
except errors.NotBranchError:
136
basis_branch = None
137
try:
138
basis_repo = basis.open_repository()
139
except errors.NoRepositoryPresent:
140
basis_repo = None
141
return basis_repo, basis_branch, basis_tree
142
143
def _make_tail(self, url):
144
segments = url.split('/')
145
if segments and segments[-1] not in ('', '.'):
146
parent = '/'.join(segments[:-1])
147
t = bzrlib.transport.get_transport(parent)
148
try:
149
t.mkdir(segments[-1])
150
except errors.FileExists:
151
pass
152
153
@staticmethod
154
def create(base):
155
"""Create a new BzrDir at the url 'base'.
156
157
This will call the current default formats initialize with base
158
as the only parameter.
159
160
If you need a specific format, consider creating an instance
161
of that and calling initialize().
162
"""
163
segments = base.split('/')
164
if segments and segments[-1] not in ('', '.'):
165
parent = '/'.join(segments[:-1])
166
t = bzrlib.transport.get_transport(parent)
167
try:
168
t.mkdir(segments[-1])
169
except errors.FileExists:
170
pass
171
return BzrDirFormat.get_default_format().initialize(safe_unicode(base))
172
173
def create_branch(self):
174
"""Create a branch in this BzrDir.
175
176
The bzrdirs format will control what branch format is created.
177
For more control see BranchFormatXX.create(a_bzrdir).
178
"""
179
raise NotImplementedError(self.create_branch)
180
181
@staticmethod
182
def create_branch_and_repo(base, force_new_repo=False):
183
"""Create a new BzrDir, Branch and Repository at the url 'base'.
184
185
This will use the current default BzrDirFormat, and use whatever
186
repository format that that uses via bzrdir.create_branch and
187
create_repository. If a shared repository is available that is used
188
preferentially.
189
190
The created Branch object is returned.
191
192
:param base: The URL to create the branch at.
193
:param force_new_repo: If True a new repository is always created.
194
"""
195
bzrdir = BzrDir.create(base)
196
bzrdir._find_or_create_repository(force_new_repo)
197
return bzrdir.create_branch()
198
199
def _find_or_create_repository(self, force_new_repo):
200
"""Create a new repository if needed, returning the repository."""
201
if force_new_repo:
202
return self.create_repository()
203
try:
204
return self.find_repository()
205
except errors.NoRepositoryPresent:
206
return self.create_repository()
207
208
@staticmethod
209
def create_branch_convenience(base, force_new_repo=False, force_new_tree=None):
210
"""Create a new BzrDir, Branch and Repository at the url 'base'.
211
212
This is a convenience function - it will use an existing repository
213
if possible, can be told explicitly whether to create a working tree or
214
not.
215
216
This will use the current default BzrDirFormat, and use whatever
217
repository format that that uses via bzrdir.create_branch and
218
create_repository. If a shared repository is available that is used
219
preferentially. Whatever repository is used, its tree creation policy
220
is followed.
221
222
The created Branch object is returned.
223
If a working tree cannot be made due to base not being a file:// url,
224
no error is raised unless force_new_tree is True, in which case no
225
data is created on disk and NotLocalUrl is raised.
226
227
:param base: The URL to create the branch at.
228
:param force_new_repo: If True a new repository is always created.
229
:param force_new_tree: If True or False force creation of a tree or
230
prevent such creation respectively.
231
"""
232
if force_new_tree:
233
# check for non local urls
234
t = get_transport(safe_unicode(base))
235
if not isinstance(t, LocalTransport):
236
raise errors.NotLocalUrl(base)
237
bzrdir = BzrDir.create(base)
238
repo = bzrdir._find_or_create_repository(force_new_repo)
239
result = bzrdir.create_branch()
240
if force_new_tree or (repo.make_working_trees() and
241
force_new_tree is None):
242
try:
243
bzrdir.create_workingtree()
244
except errors.NotLocalUrl:
245
pass
246
return result
247
248
@staticmethod
249
def create_repository(base, shared=False):
250
"""Create a new BzrDir and Repository at the url 'base'.
251
252
This will use the current default BzrDirFormat, and use whatever
253
repository format that that uses for bzrdirformat.create_repository.
254
255
;param shared: Create a shared repository rather than a standalone
256
repository.
257
The Repository object is returned.
258
259
This must be overridden as an instance method in child classes, where
260
it should take no parameters and construct whatever repository format
261
that child class desires.
262
"""
263
bzrdir = BzrDir.create(base)
264
return bzrdir.create_repository()
265
266
@staticmethod
267
def create_standalone_workingtree(base):
268
"""Create a new BzrDir, WorkingTree, Branch and Repository at 'base'.
269
270
'base' must be a local path or a file:// url.
271
272
This will use the current default BzrDirFormat, and use whatever
273
repository format that that uses for bzrdirformat.create_workingtree,
274
create_branch and create_repository.
275
276
The WorkingTree object is returned.
277
"""
278
t = get_transport(safe_unicode(base))
279
if not isinstance(t, LocalTransport):
280
raise errors.NotLocalUrl(base)
281
bzrdir = BzrDir.create_branch_and_repo(safe_unicode(base),
282
force_new_repo=True).bzrdir
283
return bzrdir.create_workingtree()
284
285
def create_workingtree(self, revision_id=None):
286
"""Create a working tree at this BzrDir.
287
288
revision_id: create it as of this revision id.
289
"""
290
raise NotImplementedError(self.create_workingtree)
291
292
def find_repository(self):
293
"""Find the repository that should be used for a_bzrdir.
294
295
This does not require a branch as we use it to find the repo for
296
new branches as well as to hook existing branches up to their
297
repository.
298
"""
299
try:
300
return self.open_repository()
301
except errors.NoRepositoryPresent:
302
pass
303
next_transport = self.root_transport.clone('..')
304
while True:
305
try:
306
found_bzrdir = BzrDir.open_containing_from_transport(
307
next_transport)[0]
308
except errors.NotBranchError:
309
raise errors.NoRepositoryPresent(self)
310
try:
311
repository = found_bzrdir.open_repository()
312
except errors.NoRepositoryPresent:
313
next_transport = found_bzrdir.root_transport.clone('..')
314
continue
315
if ((found_bzrdir.root_transport.base ==
316
self.root_transport.base) or repository.is_shared()):
317
return repository
318
else:
319
raise errors.NoRepositoryPresent(self)
320
raise errors.NoRepositoryPresent(self)
321
322
def get_branch_transport(self, branch_format):
323
"""Get the transport for use by branch format in this BzrDir.
324
325
Note that bzr dirs that do not support format strings will raise
326
IncompatibleFormat if the branch format they are given has
327
a format string, and vice verca.
328
329
If branch_format is None, the transport is returned with no
330
checking. if it is not None, then the returned transport is
331
guaranteed to point to an existing directory ready for use.
332
"""
333
raise NotImplementedError(self.get_branch_transport)
334
335
def get_repository_transport(self, repository_format):
336
"""Get the transport for use by repository format in this BzrDir.
337
338
Note that bzr dirs that do not support format strings will raise
339
IncompatibleFormat if the repository format they are given has
340
a format string, and vice verca.
341
342
If repository_format is None, the transport is returned with no
343
checking. if it is not None, then the returned transport is
344
guaranteed to point to an existing directory ready for use.
345
"""
346
raise NotImplementedError(self.get_repository_transport)
347
348
def get_workingtree_transport(self, tree_format):
349
"""Get the transport for use by workingtree format in this BzrDir.
350
351
Note that bzr dirs that do not support format strings will raise
352
IncompatibleFormat if the workingtree format they are given has
353
a format string, and vice verca.
354
355
If workingtree_format is None, the transport is returned with no
356
checking. if it is not None, then the returned transport is
357
guaranteed to point to an existing directory ready for use.
358
"""
359
raise NotImplementedError(self.get_workingtree_transport)
360
361
def __init__(self, _transport, _format):
362
"""Initialize a Bzr control dir object.
363
364
Only really common logic should reside here, concrete classes should be
365
made with varying behaviours.
366
367
:param _format: the format that is creating this BzrDir instance.
368
:param _transport: the transport this dir is based at.
369
"""
370
self._format = _format
371
self.transport = _transport.clone('.bzr')
372
self.root_transport = _transport
373
374
def needs_format_conversion(self, format=None):
375
"""Return true if this bzrdir needs convert_format run on it.
376
377
For instance, if the repository format is out of date but the
378
branch and working tree are not, this should return True.
379
380
:param format: Optional parameter indicating a specific desired
381
format we plan to arrive at.
382
"""
383
raise NotImplementedError(self.needs_format_conversion)
384
385
@staticmethod
386
def open_unsupported(base):
387
"""Open a branch which is not supported."""
388
return BzrDir.open(base, _unsupported=True)
389
390
@staticmethod
391
def open(base, _unsupported=False):
392
"""Open an existing bzrdir, rooted at 'base' (url)
393
394
_unsupported is a private parameter to the BzrDir class.
395
"""
396
t = get_transport(base)
397
mutter("trying to open %r with transport %r", base, t)
398
format = BzrDirFormat.find_format(t)
399
if not _unsupported and not format.is_supported():
400
# see open_downlevel to open legacy branches.
401
raise errors.UnsupportedFormatError(
402
'sorry, format %s not supported' % format,
403
['use a different bzr version',
404
'or remove the .bzr directory'
405
' and "bzr init" again'])
406
return format.open(t, _found=True)
407
408
def open_branch(self, unsupported=False):
409
"""Open the branch object at this BzrDir if one is present.
410
411
If unsupported is True, then no longer supported branch formats can
412
still be opened.
413
414
TODO: static convenience version of this?
415
"""
416
raise NotImplementedError(self.open_branch)
417
418
@staticmethod
419
def open_containing(url):
420
"""Open an existing branch which contains url.
421
422
:param url: url to search from.
423
See open_containing_from_transport for more detail.
424
"""
425
return BzrDir.open_containing_from_transport(get_transport(url))
426
427
@staticmethod
428
def open_containing_from_transport(a_transport):
429
"""Open an existing branch which contains a_transport.base
430
431
This probes for a branch at a_transport, and searches upwards from there.
432
433
Basically we keep looking up until we find the control directory or
434
run into the root. If there isn't one, raises NotBranchError.
435
If there is one and it is either an unrecognised format or an unsupported
436
format, UnknownFormatError or UnsupportedFormatError are raised.
437
If there is one, it is returned, along with the unused portion of url.
438
"""
439
# this gets the normalised url back. I.e. '.' -> the full path.
440
url = a_transport.base
441
while True:
442
try:
443
format = BzrDirFormat.find_format(a_transport)
444
return format.open(a_transport), a_transport.relpath(url)
445
except errors.NotBranchError, e:
446
mutter('not a branch in: %r %s', a_transport.base, e)
447
new_t = a_transport.clone('..')
448
if new_t.base == a_transport.base:
449
# reached the root, whatever that may be
450
raise errors.NotBranchError(path=url)
451
a_transport = new_t
452
453
def open_repository(self, _unsupported=False):
454
"""Open the repository object at this BzrDir if one is present.
455
456
This will not follow the Branch object pointer - its strictly a direct
457
open facility. Most client code should use open_branch().repository to
458
get at a repository.
459
460
_unsupported is a private parameter, not part of the api.
461
TODO: static convenience version of this?
462
"""
463
raise NotImplementedError(self.open_repository)
464
465
def open_workingtree(self, _unsupported=False):
466
"""Open the workingtree object at this BzrDir if one is present.
467
468
TODO: static convenience version of this?
469
"""
470
raise NotImplementedError(self.open_workingtree)
471
472
def sprout(self, url, revision_id=None, basis=None, force_new_repo=False):
473
"""Create a copy of this bzrdir prepared for use as a new line of
474
development.
475
476
If urls last component does not exist, it will be created.
477
478
Attributes related to the identity of the source branch like
479
branch nickname will be cleaned, a working tree is created
480
whether one existed before or not; and a local branch is always
481
created.
482
483
if revision_id is not None, then the clone operation may tune
484
itself to download less data.
485
"""
486
self._make_tail(url)
487
result = self._format.initialize(url)
488
basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
489
try:
490
source_branch = self.open_branch()
491
source_repository = source_branch.repository
492
except errors.NotBranchError:
493
source_branch = None
494
try:
495
source_repository = self.open_repository()
496
except errors.NoRepositoryPresent:
497
# copy the entire basis one if there is one
498
# but there is no repository.
499
source_repository = basis_repo
500
if force_new_repo:
501
result_repo = None
502
else:
503
try:
504
result_repo = result.find_repository()
505
except errors.NoRepositoryPresent:
506
result_repo = None
507
if source_repository is None and result_repo is not None:
508
pass
509
elif source_repository is None and result_repo is None:
510
# no repo available, make a new one
511
result.create_repository()
512
elif source_repository is not None and result_repo is None:
513
# have soure, and want to make a new target repo
514
source_repository.clone(result,
515
revision_id=revision_id,
516
basis=basis_repo)
517
else:
518
# fetch needed content into target.
519
if basis_repo:
520
# XXX FIXME RBC 20060214 need tests for this when the basis
521
# is incomplete
522
result_repo.fetch(basis_repo, revision_id=revision_id)
523
result_repo.fetch(source_repository, revision_id=revision_id)
524
if source_branch is not None:
525
source_branch.sprout(result, revision_id=revision_id)
526
else:
527
result.create_branch()
528
result.create_workingtree()
529
return result
530
531
532
class BzrDirPreSplitOut(BzrDir):
533
"""A common class for the all-in-one formats."""
534
535
def __init__(self, _transport, _format):
536
"""See BzrDir.__init__."""
537
super(BzrDirPreSplitOut, self).__init__(_transport, _format)
538
self._control_files = LockableFiles(self.get_branch_transport(None),
539
'branch-lock',
540
TransportLock)
541
542
def clone(self, url, revision_id=None, basis=None, force_new_repo=False):
543
"""See BzrDir.clone()."""
544
from bzrlib.workingtree import WorkingTreeFormat2
545
self._make_tail(url)
546
result = self._format.initialize(url, _cloning=True)
547
basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
548
self.open_repository().clone(result, revision_id=revision_id, basis=basis_repo)
549
self.open_branch().clone(result, revision_id=revision_id)
550
try:
551
self.open_workingtree().clone(result, basis=basis_tree)
552
except errors.NotLocalUrl:
553
# make a new one, this format always has to have one.
554
try:
555
WorkingTreeFormat2().initialize(result)
556
except errors.NotLocalUrl:
557
# but we canot do it for remote trees.
558
pass
559
return result
560
561
def create_branch(self):
562
"""See BzrDir.create_branch."""
563
return self.open_branch()
564
565
def create_repository(self, shared=False):
566
"""See BzrDir.create_repository."""
567
if shared:
568
raise errors.IncompatibleFormat('shared repository', self._format)
569
return self.open_repository()
570
571
def create_workingtree(self, revision_id=None):
572
"""See BzrDir.create_workingtree."""
573
# this looks buggy but is not -really-
574
# clone and sprout will have set the revision_id
575
# and that will have set it for us, its only
576
# specific uses of create_workingtree in isolation
577
# that can do wonky stuff here, and that only
578
# happens for creating checkouts, which cannot be
579
# done on this format anyway. So - acceptable wart.
580
result = self.open_workingtree()
581
if revision_id is not None:
582
result.set_last_revision(revision_id)
583
return result
584
585
def get_branch_transport(self, branch_format):
586
"""See BzrDir.get_branch_transport()."""
587
if branch_format is None:
588
return self.transport
589
try:
590
branch_format.get_format_string()
591
except NotImplementedError:
592
return self.transport
593
raise errors.IncompatibleFormat(branch_format, self._format)
594
595
def get_repository_transport(self, repository_format):
596
"""See BzrDir.get_repository_transport()."""
597
if repository_format is None:
598
return self.transport
599
try:
600
repository_format.get_format_string()
601
except NotImplementedError:
602
return self.transport
603
raise errors.IncompatibleFormat(repository_format, self._format)
604
605
def get_workingtree_transport(self, workingtree_format):
606
"""See BzrDir.get_workingtree_transport()."""
607
if workingtree_format is None:
608
return self.transport
609
try:
610
workingtree_format.get_format_string()
611
except NotImplementedError:
612
return self.transport
613
raise errors.IncompatibleFormat(workingtree_format, self._format)
614
615
def needs_format_conversion(self, format=None):
616
"""See BzrDir.needs_format_conversion()."""
617
# if the format is not the same as the system default,
618
# an upgrade is needed.
619
if format is None:
620
format = BzrDirFormat.get_default_format()
621
return not isinstance(self._format, format.__class__)
622
623
def open_branch(self, unsupported=False):
624
"""See BzrDir.open_branch."""
625
from bzrlib.branch import BzrBranchFormat4
626
format = BzrBranchFormat4()
627
self._check_supported(format, unsupported)
628
return format.open(self, _found=True)
629
630
def sprout(self, url, revision_id=None, basis=None):
631
"""See BzrDir.sprout()."""
632
from bzrlib.workingtree import WorkingTreeFormat2
633
self._make_tail(url)
634
result = self._format.initialize(url, _cloning=True)
635
basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
636
try:
637
self.open_repository().clone(result, revision_id=revision_id, basis=basis_repo)
638
except errors.NoRepositoryPresent:
639
pass
640
try:
641
self.open_branch().sprout(result, revision_id=revision_id)
642
except errors.NotBranchError:
643
pass
644
# we always want a working tree
645
WorkingTreeFormat2().initialize(result)
646
return result
647
648
649
class BzrDir4(BzrDirPreSplitOut):
650
"""A .bzr version 4 control object.
651
652
This is a deprecated format and may be removed after sept 2006.
653
"""
654
655
def create_repository(self, shared=False):
656
"""See BzrDir.create_repository."""
657
return self._format.repository_format.initialize(self, shared)
658
659
def needs_format_conversion(self, format=None):
660
"""Format 4 dirs are always in need of conversion."""
661
return True
662
663
def open_repository(self):
664
"""See BzrDir.open_repository."""
665
from bzrlib.repository import RepositoryFormat4
666
return RepositoryFormat4().open(self, _found=True)
667
668
669
class BzrDir5(BzrDirPreSplitOut):
670
"""A .bzr version 5 control object.
671
672
This is a deprecated format and may be removed after sept 2006.
673
"""
674
675
def open_repository(self):
676
"""See BzrDir.open_repository."""
677
from bzrlib.repository import RepositoryFormat5
678
return RepositoryFormat5().open(self, _found=True)
679
680
def open_workingtree(self, _unsupported=False):
681
"""See BzrDir.create_workingtree."""
682
from bzrlib.workingtree import WorkingTreeFormat2
683
return WorkingTreeFormat2().open(self, _found=True)
684
685
686
class BzrDir6(BzrDirPreSplitOut):
687
"""A .bzr version 6 control object.
688
689
This is a deprecated format and may be removed after sept 2006.
690
"""
691
692
def open_repository(self):
693
"""See BzrDir.open_repository."""
694
from bzrlib.repository import RepositoryFormat6
695
return RepositoryFormat6().open(self, _found=True)
696
697
def open_workingtree(self, _unsupported=False):
698
"""See BzrDir.create_workingtree."""
699
from bzrlib.workingtree import WorkingTreeFormat2
700
return WorkingTreeFormat2().open(self, _found=True)
701
702
703
class BzrDirMeta1(BzrDir):
704
"""A .bzr meta version 1 control object.
705
706
This is the first control object where the
707
individual formats are really split out.
708
"""
709
710
def can_convert_format(self):
711
"""See BzrDir.can_convert_format()."""
712
return True
713
714
def create_branch(self):
715
"""See BzrDir.create_branch."""
716
from bzrlib.branch import BranchFormat
717
return BranchFormat.get_default_format().initialize(self)
718
719
def create_repository(self, shared=False):
720
"""See BzrDir.create_repository."""
721
return self._format.repository_format.initialize(self, shared)
722
723
def create_workingtree(self, revision_id=None):
724
"""See BzrDir.create_workingtree."""
725
from bzrlib.workingtree import WorkingTreeFormat
726
return WorkingTreeFormat.get_default_format().initialize(self, revision_id)
727
728
def get_branch_transport(self, branch_format):
729
"""See BzrDir.get_branch_transport()."""
730
if branch_format is None:
731
return self.transport.clone('branch')
732
try:
733
branch_format.get_format_string()
734
except NotImplementedError:
735
raise errors.IncompatibleFormat(branch_format, self._format)
736
try:
737
self.transport.mkdir('branch')
738
except errors.FileExists:
739
pass
740
return self.transport.clone('branch')
741
742
def get_repository_transport(self, repository_format):
743
"""See BzrDir.get_repository_transport()."""
744
if repository_format is None:
745
return self.transport.clone('repository')
746
try:
747
repository_format.get_format_string()
748
except NotImplementedError:
749
raise errors.IncompatibleFormat(repository_format, self._format)
750
try:
751
self.transport.mkdir('repository')
752
except errors.FileExists:
753
pass
754
return self.transport.clone('repository')
755
756
def get_workingtree_transport(self, workingtree_format):
757
"""See BzrDir.get_workingtree_transport()."""
758
if workingtree_format is None:
759
return self.transport.clone('checkout')
760
try:
761
workingtree_format.get_format_string()
762
except NotImplementedError:
763
raise errors.IncompatibleFormat(workingtree_format, self._format)
764
try:
765
self.transport.mkdir('checkout')
766
except errors.FileExists:
767
pass
768
return self.transport.clone('checkout')
769
770
def needs_format_conversion(self, format=None):
771
"""See BzrDir.needs_format_conversion()."""
772
if format is None:
773
format = BzrDirFormat.get_default_format()
774
if not isinstance(self._format, format.__class__):
775
# it is not a meta dir format, conversion is needed.
776
return True
777
# we might want to push this down to the repository?
778
try:
779
if not isinstance(self.open_repository()._format,
780
format.repository_format.__class__):
781
# the repository needs an upgrade.
782
return True
783
except errors.NoRepositoryPresent:
784
pass
785
# currently there are no other possible conversions for meta1 formats.
786
return False
787
788
def open_branch(self, unsupported=False):
789
"""See BzrDir.open_branch."""
790
from bzrlib.branch import BranchFormat
791
format = BranchFormat.find_format(self)
792
self._check_supported(format, unsupported)
793
return format.open(self, _found=True)
794
795
def open_repository(self, unsupported=False):
796
"""See BzrDir.open_repository."""
797
from bzrlib.repository import RepositoryFormat
798
format = RepositoryFormat.find_format(self)
799
self._check_supported(format, unsupported)
800
return format.open(self, _found=True)
801
802
def open_workingtree(self, unsupported=False):
803
"""See BzrDir.open_workingtree."""
804
from bzrlib.workingtree import WorkingTreeFormat
805
format = WorkingTreeFormat.find_format(self)
806
self._check_supported(format, unsupported)
807
return format.open(self, _found=True)
808
809
810
class BzrDirFormat(object):
811
"""An encapsulation of the initialization and open routines for a format.
812
813
Formats provide three things:
814
* An initialization routine,
815
* a format string,
816
* an open routine.
817
818
Formats are placed in an dict by their format string for reference
819
during bzrdir opening. These should be subclasses of BzrDirFormat
820
for consistency.
821
822
Once a format is deprecated, just deprecate the initialize and open
823
methods on the format class. Do not deprecate the object, as the
824
object will be created every system load.
825
"""
826
827
_default_format = None
828
"""The default format used for new .bzr dirs."""
829
830
_formats = {}
831
"""The known formats."""
832
833
@classmethod
834
def find_format(klass, transport):
835
"""Return the format registered for URL."""
836
try:
837
format_string = transport.get(".bzr/branch-format").read()
838
return klass._formats[format_string]
839
except errors.NoSuchFile:
840
raise errors.NotBranchError(path=transport.base)
841
except KeyError:
842
raise errors.UnknownFormatError(format_string)
843
844
@classmethod
845
def get_default_format(klass):
846
"""Return the current default format."""
847
return klass._default_format
848
849
def get_format_string(self):
850
"""Return the ASCII format string that identifies this format."""
851
raise NotImplementedError(self.get_format_string)
852
853
def get_converter(self, format=None):
854
"""Return the converter to use to convert bzrdirs needing converts.
855
856
This returns a bzrlib.bzrdir.Converter object.
857
858
This should return the best upgrader to step this format towards the
859
current default format. In the case of plugins we can/shouold provide
860
some means for them to extend the range of returnable converters.
861
862
:param format: Optional format to override the default foramt of the
863
library.
864
"""
865
raise NotImplementedError(self.get_converter)
866
867
def initialize(self, url):
868
"""Create a bzr control dir at this url and return an opened copy."""
869
# Since we don't have a .bzr directory, inherit the
870
# mode from the root directory
871
t = get_transport(url)
872
temp_control = LockableFiles(t, '', TransportLock)
873
temp_control._transport.mkdir('.bzr',
874
# FIXME: RBC 20060121 dont peek under
875
# the covers
876
mode=temp_control._dir_mode)
877
file_mode = temp_control._file_mode
878
del temp_control
879
mutter('created control directory in ' + t.base)
880
control = t.clone('.bzr')
881
lock_file = 'branch-lock'
882
utf8_files = [('README',
883
"This is a Bazaar-NG control directory.\n"
884
"Do not change any files in this directory.\n"),
885
('branch-format', self.get_format_string()),
886
]
887
# NB: no need to escape relative paths that are url safe.
888
control_files = LockableFiles(control, lock_file, TransportLock)
889
control_files.create_lock()
890
control_files.lock_write()
891
try:
892
for file, content in utf8_files:
893
control_files.put_utf8(file, content)
894
finally:
895
control_files.unlock()
896
return self.open(t, _found=True)
897
898
def is_supported(self):
899
"""Is this format supported?
900
901
Supported formats must be initializable and openable.
902
Unsupported formats may not support initialization or committing or
903
some other features depending on the reason for not being supported.
904
"""
905
return True
906
907
def open(self, transport, _found=False):
908
"""Return an instance of this format for the dir transport points at.
909
910
_found is a private parameter, do not use it.
911
"""
912
if not _found:
913
assert isinstance(BzrDirFormat.find_format(transport),
914
self.__class__)
915
return self._open(transport)
916
917
def _open(self, transport):
918
"""Template method helper for opening BzrDirectories.
919
920
This performs the actual open and any additional logic or parameter
921
passing.
922
"""
923
raise NotImplementedError(self._open)
924
925
@classmethod
926
def register_format(klass, format):
927
klass._formats[format.get_format_string()] = format
928
929
@classmethod
930
def set_default_format(klass, format):
931
klass._default_format = format
932
933
def __str__(self):
934
return self.get_format_string()[:-1]
935
936
@classmethod
937
def unregister_format(klass, format):
938
assert klass._formats[format.get_format_string()] is format
939
del klass._formats[format.get_format_string()]
940
941
942
class BzrDirFormat4(BzrDirFormat):
943
"""Bzr dir format 4.
944
945
This format is a combined format for working tree, branch and repository.
946
It has:
947
- Format 1 working trees [always]
948
- Format 4 branches [always]
949
- Format 4 repositories [always]
950
951
This format is deprecated: it indexes texts using a text it which is
952
removed in format 5; write support for this format has been removed.
953
"""
954
955
def get_format_string(self):
956
"""See BzrDirFormat.get_format_string()."""
957
return "Bazaar-NG branch, format 0.0.4\n"
958
959
def get_converter(self, format=None):
960
"""See BzrDirFormat.get_converter()."""
961
# there is one and only one upgrade path here.
962
return ConvertBzrDir4To5()
963
964
def initialize(self, url):
965
"""Format 4 branches cannot be created."""
966
raise errors.UninitializableFormat(self)
967
968
def is_supported(self):
969
"""Format 4 is not supported.
970
971
It is not supported because the model changed from 4 to 5 and the
972
conversion logic is expensive - so doing it on the fly was not
973
feasible.
974
"""
975
return False
976
977
def _open(self, transport):
978
"""See BzrDirFormat._open."""
979
return BzrDir4(transport, self)
980
981
def __return_repository_format(self):
982
"""Circular import protection."""
983
from bzrlib.repository import RepositoryFormat4
984
return RepositoryFormat4(self)
985
repository_format = property(__return_repository_format)
986
987
988
class BzrDirFormat5(BzrDirFormat):
989
"""Bzr control format 5.
990
991
This format is a combined format for working tree, branch and repository.
992
It has:
993
- Format 2 working trees [always]
994
- Format 4 branches [always]
995
- Format 5 repositories [always]
996
Unhashed stores in the repository.
997
"""
998
999
def get_format_string(self):
1000
"""See BzrDirFormat.get_format_string()."""
1001
return "Bazaar-NG branch, format 5\n"
1002
1003
def get_converter(self, format=None):
1004
"""See BzrDirFormat.get_converter()."""
1005
# there is one and only one upgrade path here.
1006
return ConvertBzrDir5To6()
1007
1008
def initialize(self, url, _cloning=False):
1009
"""Format 5 dirs always have working tree, branch and repository.
1010
1011
Except when they are being cloned.
1012
"""
1013
from bzrlib.branch import BzrBranchFormat4
1014
from bzrlib.repository import RepositoryFormat5
1015
from bzrlib.workingtree import WorkingTreeFormat2
1016
result = super(BzrDirFormat5, self).initialize(url)
1017
RepositoryFormat5().initialize(result, _internal=True)
1018
if not _cloning:
1019
BzrBranchFormat4().initialize(result)
1020
WorkingTreeFormat2().initialize(result)
1021
return result
1022
1023
def _open(self, transport):
1024
"""See BzrDirFormat._open."""
1025
return BzrDir5(transport, self)
1026
1027
def __return_repository_format(self):
1028
"""Circular import protection."""
1029
from bzrlib.repository import RepositoryFormat5
1030
return RepositoryFormat5(self)
1031
repository_format = property(__return_repository_format)
1032
1033
1034
class BzrDirFormat6(BzrDirFormat):
1035
"""Bzr control format 6.
1036
1037
This format is a combined format for working tree, branch and repository.
1038
It has:
1039
- Format 2 working trees [always]
1040
- Format 4 branches [always]
1041
- Format 6 repositories [always]
1042
"""
1043
1044
def get_format_string(self):
1045
"""See BzrDirFormat.get_format_string()."""
1046
return "Bazaar-NG branch, format 6\n"
1047
1048
def get_converter(self, format=None):
1049
"""See BzrDirFormat.get_converter()."""
1050
# there is one and only one upgrade path here.
1051
return ConvertBzrDir6ToMeta()
1052
1053
def initialize(self, url, _cloning=False):
1054
"""Format 6 dirs always have working tree, branch and repository.
1055
1056
Except when they are being cloned.
1057
"""
1058
from bzrlib.branch import BzrBranchFormat4
1059
from bzrlib.repository import RepositoryFormat6
1060
from bzrlib.workingtree import WorkingTreeFormat2
1061
result = super(BzrDirFormat6, self).initialize(url)
1062
RepositoryFormat6().initialize(result, _internal=True)
1063
if not _cloning:
1064
BzrBranchFormat4().initialize(result)
1065
try:
1066
WorkingTreeFormat2().initialize(result)
1067
except errors.NotLocalUrl:
1068
# emulate pre-check behaviour for working tree and silently
1069
# fail.
1070
pass
1071
return result
1072
1073
def _open(self, transport):
1074
"""See BzrDirFormat._open."""
1075
return BzrDir6(transport, self)
1076
1077
def __return_repository_format(self):
1078
"""Circular import protection."""
1079
from bzrlib.repository import RepositoryFormat6
1080
return RepositoryFormat6(self)
1081
repository_format = property(__return_repository_format)
1082
1083
1084
class BzrDirMetaFormat1(BzrDirFormat):
1085
"""Bzr meta control format 1
1086
1087
This is the first format with split out working tree, branch and repository
1088
disk storage.
1089
It has:
1090
- Format 3 working trees [optional]
1091
- Format 5 branches [optional]
1092
- Format 7 repositories [optional]
1093
"""
1094
1095
def get_converter(self, format=None):
1096
"""See BzrDirFormat.get_converter()."""
1097
if format is None:
1098
format = BzrDirFormat.get_default_format()
1099
if not isinstance(self, format.__class__):
1100
# converting away from metadir is not implemented
1101
raise NotImplementedError(self.get_converter)
1102
return ConvertMetaToMeta(format)
1103
1104
def get_format_string(self):
1105
"""See BzrDirFormat.get_format_string()."""
1106
return "Bazaar-NG meta directory, format 1\n"
1107
1108
def _open(self, transport):
1109
"""See BzrDirFormat._open."""
1110
return BzrDirMeta1(transport, self)
1111
1112
def __return_repository_format(self):
1113
"""Circular import protection."""
1114
if getattr(self, '_repository_format', None):
1115
return self._repository_format
1116
from bzrlib.repository import RepositoryFormat
1117
return RepositoryFormat.get_default_format()
1118
1119
def __set_repository_format(self, value):
1120
"""Allow changint the repository format for metadir formats."""
1121
self._repository_format = value
1122
repository_format = property(__return_repository_format, __set_repository_format)
1123
1124
1125
BzrDirFormat.register_format(BzrDirFormat4())
1126
BzrDirFormat.register_format(BzrDirFormat5())
1127
BzrDirFormat.register_format(BzrDirMetaFormat1())
1128
__default_format = BzrDirFormat6()
1129
BzrDirFormat.register_format(__default_format)
1130
BzrDirFormat.set_default_format(__default_format)
1131
1132
1133
class BzrDirTestProviderAdapter(object):
1134
"""A tool to generate a suite testing multiple bzrdir formats at once.
1135
1136
This is done by copying the test once for each transport and injecting
1137
the transport_server, transport_readonly_server, and bzrdir_format
1138
classes into each copy. Each copy is also given a new id() to make it
1139
easy to identify.
1140
"""
1141
1142
def __init__(self, transport_server, transport_readonly_server, formats):
1143
self._transport_server = transport_server
1144
self._transport_readonly_server = transport_readonly_server
1145
self._formats = formats
1146
1147
def adapt(self, test):
1148
result = TestSuite()
1149
for format in self._formats:
1150
new_test = deepcopy(test)
1151
new_test.transport_server = self._transport_server
1152
new_test.transport_readonly_server = self._transport_readonly_server
1153
new_test.bzrdir_format = format
1154
def make_new_test_id():
1155
new_id = "%s(%s)" % (new_test.id(), format.__class__.__name__)
1156
return lambda: new_id
1157
new_test.id = make_new_test_id()
1158
result.addTest(new_test)
1159
return result
1160
1161
1162
class ScratchDir(BzrDir6):
1163
"""Special test class: a bzrdir that cleans up itself..
1164
1165
>>> d = ScratchDir()
1166
>>> base = d.transport.base
1167
>>> isdir(base)
1168
True
1169
>>> b.transport.__del__()
1170
>>> isdir(base)
1171
False
1172
"""
1173
1174
def __init__(self, files=[], dirs=[], transport=None):
1175
"""Make a test branch.
1176
1177
This creates a temporary directory and runs init-tree in it.
1178
1179
If any files are listed, they are created in the working copy.
1180
"""
1181
if transport is None:
1182
transport = bzrlib.transport.local.ScratchTransport()
1183
# local import for scope restriction
1184
BzrDirFormat6().initialize(transport.base)
1185
super(ScratchDir, self).__init__(transport, BzrDirFormat6())
1186
self.create_repository()
1187
self.create_branch()
1188
self.create_workingtree()
1189
else:
1190
super(ScratchDir, self).__init__(transport, BzrDirFormat6())
1191
1192
# BzrBranch creates a clone to .bzr and then forgets about the
1193
# original transport. A ScratchTransport() deletes itself and
1194
# everything underneath it when it goes away, so we need to
1195
# grab a local copy to prevent that from happening
1196
self._transport = transport
1197
1198
for d in dirs:
1199
self._transport.mkdir(d)
1200
1201
for f in files:
1202
self._transport.put(f, 'content of %s' % f)
1203
1204
def clone(self):
1205
"""
1206
>>> orig = ScratchDir(files=["file1", "file2"])
1207
>>> os.listdir(orig.base)
1208
[u'.bzr', u'file1', u'file2']
1209
>>> clone = orig.clone()
1210
>>> if os.name != 'nt':
1211
... os.path.samefile(orig.base, clone.base)
1212
... else:
1213
... orig.base == clone.base
1214
...
1215
False
1216
>>> os.listdir(clone.base)
1217
[u'.bzr', u'file1', u'file2']
1218
"""
1219
from shutil import copytree
1220
from bzrlib.osutils import mkdtemp
1221
base = mkdtemp()
1222
os.rmdir(base)
1223
copytree(self.base, base, symlinks=True)
1224
return ScratchDir(
1225
transport=bzrlib.transport.local.ScratchTransport(base))
1226
1227
1228
class Converter(object):
1229
"""Converts a disk format object from one format to another."""
1230
1231
def convert(self, to_convert, pb):
1232
"""Perform the conversion of to_convert, giving feedback via pb.
1233
1234
:param to_convert: The disk object to convert.
1235
:param pb: a progress bar to use for progress information.
1236
"""
1237
1238
def step(self, message):
1239
"""Update the pb by a step."""
1240
self.count +=1
1241
self.pb.update(message, self.count, self.total)
1242
1243
1244
class ConvertBzrDir4To5(Converter):
1245
"""Converts format 4 bzr dirs to format 5."""
1246
1247
def __init__(self):
1248
super(ConvertBzrDir4To5, self).__init__()
1249
self.converted_revs = set()
1250
self.absent_revisions = set()
1251
self.text_count = 0
1252
self.revisions = {}
1253
1254
def convert(self, to_convert, pb):
1255
"""See Converter.convert()."""
1256
self.bzrdir = to_convert
1257
self.pb = pb
1258
self.pb.note('starting upgrade from format 4 to 5')
1259
if isinstance(self.bzrdir.transport, LocalTransport):
1260
self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
1261
self._convert_to_weaves()
1262
return BzrDir.open(self.bzrdir.root_transport.base)
1263
1264
def _convert_to_weaves(self):
1265
self.pb.note('note: upgrade may be faster if all store files are ungzipped first')
1266
try:
1267
# TODO permissions
1268
stat = self.bzrdir.transport.stat('weaves')
1269
if not S_ISDIR(stat.st_mode):
1270
self.bzrdir.transport.delete('weaves')
1271
self.bzrdir.transport.mkdir('weaves')
1272
except errors.NoSuchFile:
1273
self.bzrdir.transport.mkdir('weaves')
1274
# deliberately not a WeaveFile as we want to build it up slowly.
1275
self.inv_weave = Weave('inventory')
1276
# holds in-memory weaves for all files
1277
self.text_weaves = {}
1278
self.bzrdir.transport.delete('branch-format')
1279
self.branch = self.bzrdir.open_branch()
1280
self._convert_working_inv()
1281
rev_history = self.branch.revision_history()
1282
# to_read is a stack holding the revisions we still need to process;
1283
# appending to it adds new highest-priority revisions
1284
self.known_revisions = set(rev_history)
1285
self.to_read = rev_history[-1:]
1286
while self.to_read:
1287
rev_id = self.to_read.pop()
1288
if (rev_id not in self.revisions
1289
and rev_id not in self.absent_revisions):
1290
self._load_one_rev(rev_id)
1291
self.pb.clear()
1292
to_import = self._make_order()
1293
for i, rev_id in enumerate(to_import):
1294
self.pb.update('converting revision', i, len(to_import))
1295
self._convert_one_rev(rev_id)
1296
self.pb.clear()
1297
self._write_all_weaves()
1298
self._write_all_revs()
1299
self.pb.note('upgraded to weaves:')
1300
self.pb.note(' %6d revisions and inventories', len(self.revisions))
1301
self.pb.note(' %6d revisions not present', len(self.absent_revisions))
1302
self.pb.note(' %6d texts', self.text_count)
1303
self._cleanup_spare_files_after_format4()
1304
self.branch.control_files.put_utf8('branch-format', BzrDirFormat5().get_format_string())
1305
1306
def _cleanup_spare_files_after_format4(self):
1307
# FIXME working tree upgrade foo.
1308
for n in 'merged-patches', 'pending-merged-patches':
1309
try:
1310
## assert os.path.getsize(p) == 0
1311
self.bzrdir.transport.delete(n)
1312
except errors.NoSuchFile:
1313
pass
1314
self.bzrdir.transport.delete_tree('inventory-store')
1315
self.bzrdir.transport.delete_tree('text-store')
1316
1317
def _convert_working_inv(self):
1318
inv = serializer_v4.read_inventory(self.branch.control_files.get('inventory'))
1319
new_inv_xml = serializer_v5.write_inventory_to_string(inv)
1320
# FIXME inventory is a working tree change.
1321
self.branch.control_files.put('inventory', new_inv_xml)
1322
1323
def _write_all_weaves(self):
1324
controlweaves = WeaveStore(self.bzrdir.transport, prefixed=False)
1325
weave_transport = self.bzrdir.transport.clone('weaves')
1326
weaves = WeaveStore(weave_transport, prefixed=False)
1327
transaction = WriteTransaction()
1328
1329
try:
1330
i = 0
1331
for file_id, file_weave in self.text_weaves.items():
1332
self.pb.update('writing weave', i, len(self.text_weaves))
1333
weaves._put_weave(file_id, file_weave, transaction)
1334
i += 1
1335
self.pb.update('inventory', 0, 1)
1336
controlweaves._put_weave('inventory', self.inv_weave, transaction)
1337
self.pb.update('inventory', 1, 1)
1338
finally:
1339
self.pb.clear()
1340
1341
def _write_all_revs(self):
1342
"""Write all revisions out in new form."""
1343
self.bzrdir.transport.delete_tree('revision-store')
1344
self.bzrdir.transport.mkdir('revision-store')
1345
revision_transport = self.bzrdir.transport.clone('revision-store')
1346
# TODO permissions
1347
_revision_store = TextRevisionStore(TextStore(revision_transport,
1348
prefixed=False,
1349
compressed=True))
1350
try:
1351
transaction = bzrlib.transactions.WriteTransaction()
1352
for i, rev_id in enumerate(self.converted_revs):
1353
self.pb.update('write revision', i, len(self.converted_revs))
1354
_revision_store.add_revision(self.revisions[rev_id], transaction)
1355
finally:
1356
self.pb.clear()
1357
1358
def _load_one_rev(self, rev_id):
1359
"""Load a revision object into memory.
1360
1361
Any parents not either loaded or abandoned get queued to be
1362
loaded."""
1363
self.pb.update('loading revision',
1364
len(self.revisions),
1365
len(self.known_revisions))
1366
if not self.branch.repository.has_revision(rev_id):
1367
self.pb.clear()
1368
self.pb.note('revision {%s} not present in branch; '
1369
'will be converted as a ghost',
1370
rev_id)
1371
self.absent_revisions.add(rev_id)
1372
else:
1373
rev = self.branch.repository._revision_store.get_revision(rev_id,
1374
self.branch.repository.get_transaction())
1375
for parent_id in rev.parent_ids:
1376
self.known_revisions.add(parent_id)
1377
self.to_read.append(parent_id)
1378
self.revisions[rev_id] = rev
1379
1380
def _load_old_inventory(self, rev_id):
1381
assert rev_id not in self.converted_revs
1382
old_inv_xml = self.branch.repository.inventory_store.get(rev_id).read()
1383
inv = serializer_v4.read_inventory_from_string(old_inv_xml)
1384
rev = self.revisions[rev_id]
1385
if rev.inventory_sha1:
1386
assert rev.inventory_sha1 == sha_string(old_inv_xml), \
1387
'inventory sha mismatch for {%s}' % rev_id
1388
return inv
1389
1390
def _load_updated_inventory(self, rev_id):
1391
assert rev_id in self.converted_revs
1392
inv_xml = self.inv_weave.get_text(rev_id)
1393
inv = serializer_v5.read_inventory_from_string(inv_xml)
1394
return inv
1395
1396
def _convert_one_rev(self, rev_id):
1397
"""Convert revision and all referenced objects to new format."""
1398
rev = self.revisions[rev_id]
1399
inv = self._load_old_inventory(rev_id)
1400
present_parents = [p for p in rev.parent_ids
1401
if p not in self.absent_revisions]
1402
self._convert_revision_contents(rev, inv, present_parents)
1403
self._store_new_weave(rev, inv, present_parents)
1404
self.converted_revs.add(rev_id)
1405
1406
def _store_new_weave(self, rev, inv, present_parents):
1407
# the XML is now updated with text versions
1408
if __debug__:
1409
for file_id in inv:
1410
ie = inv[file_id]
1411
if ie.kind == 'root_directory':
1412
continue
1413
assert hasattr(ie, 'revision'), \
1414
'no revision on {%s} in {%s}' % \
1415
(file_id, rev.revision_id)
1416
new_inv_xml = serializer_v5.write_inventory_to_string(inv)
1417
new_inv_sha1 = sha_string(new_inv_xml)
1418
self.inv_weave.add_lines(rev.revision_id,
1419
present_parents,
1420
new_inv_xml.splitlines(True))
1421
rev.inventory_sha1 = new_inv_sha1
1422
1423
def _convert_revision_contents(self, rev, inv, present_parents):
1424
"""Convert all the files within a revision.
1425
1426
Also upgrade the inventory to refer to the text revision ids."""
1427
rev_id = rev.revision_id
1428
mutter('converting texts of revision {%s}',
1429
rev_id)
1430
parent_invs = map(self._load_updated_inventory, present_parents)
1431
for file_id in inv:
1432
ie = inv[file_id]
1433
self._convert_file_version(rev, ie, parent_invs)
1434
1435
def _convert_file_version(self, rev, ie, parent_invs):
1436
"""Convert one version of one file.
1437
1438
The file needs to be added into the weave if it is a merge
1439
of >=2 parents or if it's changed from its parent.
1440
"""
1441
if ie.kind == 'root_directory':
1442
return
1443
file_id = ie.file_id
1444
rev_id = rev.revision_id
1445
w = self.text_weaves.get(file_id)
1446
if w is None:
1447
w = Weave(file_id)
1448
self.text_weaves[file_id] = w
1449
text_changed = False
1450
previous_entries = ie.find_previous_heads(parent_invs, w)
1451
for old_revision in previous_entries:
1452
# if this fails, its a ghost ?
1453
assert old_revision in self.converted_revs
1454
self.snapshot_ie(previous_entries, ie, w, rev_id)
1455
del ie.text_id
1456
assert getattr(ie, 'revision', None) is not None
1457
1458
def snapshot_ie(self, previous_revisions, ie, w, rev_id):
1459
# TODO: convert this logic, which is ~= snapshot to
1460
# a call to:. This needs the path figured out. rather than a work_tree
1461
# a v4 revision_tree can be given, or something that looks enough like
1462
# one to give the file content to the entry if it needs it.
1463
# and we need something that looks like a weave store for snapshot to
1464
# save against.
1465
#ie.snapshot(rev, PATH, previous_revisions, REVISION_TREE, InMemoryWeaveStore(self.text_weaves))
1466
if len(previous_revisions) == 1:
1467
previous_ie = previous_revisions.values()[0]
1468
if ie._unchanged(previous_ie):
1469
ie.revision = previous_ie.revision
1470
return
1471
if ie.has_text():
1472
text = self.branch.repository.text_store.get(ie.text_id)
1473
file_lines = text.readlines()
1474
assert sha_strings(file_lines) == ie.text_sha1
1475
assert sum(map(len, file_lines)) == ie.text_size
1476
w.add_lines(rev_id, previous_revisions, file_lines)
1477
self.text_count += 1
1478
else:
1479
w.add_lines(rev_id, previous_revisions, [])
1480
ie.revision = rev_id
1481
1482
def _make_order(self):
1483
"""Return a suitable order for importing revisions.
1484
1485
The order must be such that an revision is imported after all
1486
its (present) parents.
1487
"""
1488
todo = set(self.revisions.keys())
1489
done = self.absent_revisions.copy()
1490
order = []
1491
while todo:
1492
# scan through looking for a revision whose parents
1493
# are all done
1494
for rev_id in sorted(list(todo)):
1495
rev = self.revisions[rev_id]
1496
parent_ids = set(rev.parent_ids)
1497
if parent_ids.issubset(done):
1498
# can take this one now
1499
order.append(rev_id)
1500
todo.remove(rev_id)
1501
done.add(rev_id)
1502
return order
1503
1504
1505
class ConvertBzrDir5To6(Converter):
1506
"""Converts format 5 bzr dirs to format 6."""
1507
1508
def convert(self, to_convert, pb):
1509
"""See Converter.convert()."""
1510
self.bzrdir = to_convert
1511
self.pb = pb
1512
self.pb.note('starting upgrade from format 5 to 6')
1513
self._convert_to_prefixed()
1514
return BzrDir.open(self.bzrdir.root_transport.base)
1515
1516
def _convert_to_prefixed(self):
1517
from bzrlib.store import hash_prefix
1518
self.bzrdir.transport.delete('branch-format')
1519
for store_name in ["weaves", "revision-store"]:
1520
self.pb.note("adding prefixes to %s" % store_name)
1521
store_transport = self.bzrdir.transport.clone(store_name)
1522
for filename in store_transport.list_dir('.'):
1523
if (filename.endswith(".weave") or
1524
filename.endswith(".gz") or
1525
filename.endswith(".sig")):
1526
file_id = os.path.splitext(filename)[0]
1527
else:
1528
file_id = filename
1529
prefix_dir = hash_prefix(file_id)
1530
# FIXME keep track of the dirs made RBC 20060121
1531
try:
1532
store_transport.move(filename, prefix_dir + '/' + filename)
1533
except errors.NoSuchFile: # catches missing dirs strangely enough
1534
store_transport.mkdir(prefix_dir)
1535
store_transport.move(filename, prefix_dir + '/' + filename)
1536
self.bzrdir._control_files.put_utf8('branch-format', BzrDirFormat6().get_format_string())
1537
1538
1539
class ConvertBzrDir6ToMeta(Converter):
1540
"""Converts format 6 bzr dirs to metadirs."""
1541
1542
def convert(self, to_convert, pb):
1543
"""See Converter.convert()."""
1544
self.bzrdir = to_convert
1545
self.pb = pb
1546
self.count = 0
1547
self.total = 20 # the steps we know about
1548
self.garbage_inventories = []
1549
1550
self.pb.note('starting upgrade from format 6 to metadir')
1551
self.bzrdir._control_files.put_utf8('branch-format', "Converting to format 6")
1552
# its faster to move specific files around than to open and use the apis...
1553
# first off, nuke ancestry.weave, it was never used.
1554
try:
1555
self.step('Removing ancestry.weave')
1556
self.bzrdir.transport.delete('ancestry.weave')
1557
except errors.NoSuchFile:
1558
pass
1559
# find out whats there
1560
self.step('Finding branch files')
1561
last_revision = self.bzrdir.open_workingtree().last_revision()
1562
bzrcontents = self.bzrdir.transport.list_dir('.')
1563
for name in bzrcontents:
1564
if name.startswith('basis-inventory.'):
1565
self.garbage_inventories.append(name)
1566
# create new directories for repository, working tree and branch
1567
dir_mode = self.bzrdir._control_files._dir_mode
1568
self.file_mode = self.bzrdir._control_files._file_mode
1569
repository_names = [('inventory.weave', True),
1570
('revision-store', True),
1571
('weaves', True)]
1572
self.step('Upgrading repository ')
1573
self.bzrdir.transport.mkdir('repository', mode=dir_mode)
1574
self.make_lock('repository')
1575
# we hard code the formats here because we are converting into
1576
# the meta format. The meta format upgrader can take this to a
1577
# future format within each component.
1578
self.put_format('repository', bzrlib.repository.RepositoryFormat7())
1579
for entry in repository_names:
1580
self.move_entry('repository', entry)
1581
1582
self.step('Upgrading branch ')
1583
self.bzrdir.transport.mkdir('branch', mode=dir_mode)
1584
self.make_lock('branch')
1585
self.put_format('branch', bzrlib.branch.BzrBranchFormat5())
1586
branch_files = [('revision-history', True),
1587
('branch-name', True),
1588
('parent', False)]
1589
for entry in branch_files:
1590
self.move_entry('branch', entry)
1591
1592
self.step('Upgrading working tree')
1593
self.bzrdir.transport.mkdir('checkout', mode=dir_mode)
1594
self.make_lock('checkout')
1595
self.put_format('checkout', bzrlib.workingtree.WorkingTreeFormat3())
1596
self.bzrdir.transport.delete_multi(self.garbage_inventories, self.pb)
1597
checkout_files = [('pending-merges', True),
1598
('inventory', True),
1599
('stat-cache', False)]
1600
for entry in checkout_files:
1601
self.move_entry('checkout', entry)
1602
if last_revision is not None:
1603
self.bzrdir._control_files.put_utf8('checkout/last-revision',
1604
last_revision)
1605
self.bzrdir._control_files.put_utf8('branch-format', BzrDirMetaFormat1().get_format_string())
1606
return BzrDir.open(self.bzrdir.root_transport.base)
1607
1608
def make_lock(self, name):
1609
"""Make a lock for the new control dir name."""
1610
self.step('Make %s lock' % name)
1611
self.bzrdir.transport.put('%s/lock' % name, StringIO(), mode=self.file_mode)
1612
1613
def move_entry(self, new_dir, entry):
1614
"""Move then entry name into new_dir."""
1615
name = entry[0]
1616
mandatory = entry[1]
1617
self.step('Moving %s' % name)
1618
try:
1619
self.bzrdir.transport.move(name, '%s/%s' % (new_dir, name))
1620
except errors.NoSuchFile:
1621
if mandatory:
1622
raise
1623
1624
def put_format(self, dirname, format):
1625
self.bzrdir._control_files.put_utf8('%s/format' % dirname, format.get_format_string())
1626
1627
1628
class ConvertMetaToMeta(Converter):
1629
"""Converts the components of metadirs."""
1630
1631
def __init__(self, target_format):
1632
"""Create a metadir to metadir converter.
1633
1634
:param target_format: The final metadir format that is desired.
1635
"""
1636
self.target_format = target_format
1637
1638
def convert(self, to_convert, pb):
1639
"""See Converter.convert()."""
1640
self.bzrdir = to_convert
1641
self.pb = pb
1642
self.count = 0
1643
self.total = 1
1644
self.step('checking repository format')
1645
try:
1646
repo = self.bzrdir.open_repository()
1647
except errors.NoRepositoryPresent:
1648
pass
1649
else:
1650
if not isinstance(repo._format, self.target_format.repository_format.__class__):
1651
from bzrlib.repository import CopyConverter
1652
self.pb.note('starting repository conversion')
1653
converter = CopyConverter(self.target_format.repository_format)
1654
converter.convert(repo, pb)
1655
return to_convert
Loggerhead is a web-based interface for Breezy
Version: 2.0.1