« back to all changes in this revision
Viewing changes to bzrlib/bzrdir.py
- browse files at revision 1553.5.68
- compare with another revision
- download diff
- download tarball
- view history from revision 1553.5.68
- Committer: Martin Pool
- Date: 2006-03-08 03:53:30 UTC
- mto: This revision was merged to the branch mainline in revision 1602.
- Revision ID: mbp@sourcefrog.net-20060308035330-40065f85adc9652e
Add new TestCaseWithTransport.assertIsDirectory() and tests
- files added:
- BRANCH.TODO
- bzrlib/doc
- bzrlib/doc/api
- bzrlib/export
- bzrlib/store
- bzrlib/tests/blackbox
- bzrlib/tests/branch_implementations
- bzrlib/tests/bzrdir_implementations
- bzrlib/tests/interrepository_implementations
- bzrlib/tests/repository_implementations
- bzrlib/tests/workingtree_implementations
- bzrlib/transport
- bzrlib/ui
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- tools/doc_generate
- files removed:
- bzrlib/changeset.py
- patches
- files renamed:
- bzrlib/store.py => bzrlib/store/__init__.py
- bzrlib/selftest/ => bzrlib/tests/
- bzrlib/selftest/teststatus.py => bzrlib/tests/blackbox/test_status.py
- bzrlib/selftest/blackbox.py => bzrlib/tests/blackbox/test_too_much.py
- bzrlib/selftest/versioning.py => bzrlib/tests/blackbox/test_versioning.py
- bzrlib/selftest/testbranch.py => bzrlib/tests/branch_implementations/test_branch.py
- bzrlib/selftest/testdiff.py => bzrlib/tests/test_diff.py
- bzrlib/selftest/testhashcache.py => bzrlib/tests/test_hashcache.py
- bzrlib/selftest/testinv.py => bzrlib/tests/test_inv.py
- bzrlib/selftest/testlog.py => bzrlib/tests/test_log.py
- bzrlib/selftest/testmerge3.py => bzrlib/tests/test_merge3.py
- bzrlib/selftest/plugins.py => bzrlib/tests/test_plugins.py
- bzrlib/selftest/testrevision.py => bzrlib/tests/test_revision.py
- bzrlib/selftest/testrevisionnamespaces.py => bzrlib/tests/test_revisionnamespaces.py
- tools/testweave.py => bzrlib/tests/test_weave.py
- bzrlib/selftest/whitebox.py => bzrlib/tests/test_whitebox.py
- tools/history2weaves.py => bzrlib/upgrade.py
- bzrlib/xml.py => bzrlib/xml_serializer.py
- bzrlib/newinventory.py => contrib/newinventory.py
- bzr-man.py => tools/doc_generate/autodoc_man.py
- files modified:
- .bzrignore
- bzr *
- setup.py *
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.text import TextStore
40
from bzrlib.store.weave import WeaveStore
41
from bzrlib.symbol_versioning import *
42
from bzrlib.trace import mutter
43
from bzrlib.transactions import PassThroughTransaction
44
from bzrlib.transport import get_transport
45
from bzrlib.transport.local import LocalTransport
46
from bzrlib.weave import Weave
47
from bzrlib.weavefile import read_weave, write_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
WorkingTreeFormat2().initialize(result)
555
return result
556
557
def create_branch(self):
558
"""See BzrDir.create_branch."""
559
return self.open_branch()
560
561
def create_repository(self, shared=False):
562
"""See BzrDir.create_repository."""
563
if shared:
564
raise errors.IncompatibleFormat('shared repository', self._format)
565
return self.open_repository()
566
567
def create_workingtree(self, revision_id=None):
568
"""See BzrDir.create_workingtree."""
569
# this looks buggy but is not -really-
570
# clone and sprout will have set the revision_id
571
# and that will have set it for us, its only
572
# specific uses of create_workingtree in isolation
573
# that can do wonky stuff here, and that only
574
# happens for creating checkouts, which cannot be
575
# done on this format anyway. So - acceptable wart.
576
result = self.open_workingtree()
577
if revision_id is not None:
578
result.set_last_revision(revision_id)
579
return result
580
581
def get_branch_transport(self, branch_format):
582
"""See BzrDir.get_branch_transport()."""
583
if branch_format is None:
584
return self.transport
585
try:
586
branch_format.get_format_string()
587
except NotImplementedError:
588
return self.transport
589
raise errors.IncompatibleFormat(branch_format, self._format)
590
591
def get_repository_transport(self, repository_format):
592
"""See BzrDir.get_repository_transport()."""
593
if repository_format is None:
594
return self.transport
595
try:
596
repository_format.get_format_string()
597
except NotImplementedError:
598
return self.transport
599
raise errors.IncompatibleFormat(repository_format, self._format)
600
601
def get_workingtree_transport(self, workingtree_format):
602
"""See BzrDir.get_workingtree_transport()."""
603
if workingtree_format is None:
604
return self.transport
605
try:
606
workingtree_format.get_format_string()
607
except NotImplementedError:
608
return self.transport
609
raise errors.IncompatibleFormat(workingtree_format, self._format)
610
611
def needs_format_conversion(self, format=None):
612
"""See BzrDir.needs_format_conversion()."""
613
# if the format is not the same as the system default,
614
# an upgrade is needed.
615
if format is None:
616
format = BzrDirFormat.get_default_format()
617
return not isinstance(self._format, format.__class__)
618
619
def open_branch(self, unsupported=False):
620
"""See BzrDir.open_branch."""
621
from bzrlib.branch import BzrBranchFormat4
622
format = BzrBranchFormat4()
623
self._check_supported(format, unsupported)
624
return format.open(self, _found=True)
625
626
def sprout(self, url, revision_id=None, basis=None):
627
"""See BzrDir.sprout()."""
628
from bzrlib.workingtree import WorkingTreeFormat2
629
self._make_tail(url)
630
result = self._format.initialize(url, _cloning=True)
631
basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
632
try:
633
self.open_repository().clone(result, revision_id=revision_id, basis=basis_repo)
634
except errors.NoRepositoryPresent:
635
pass
636
try:
637
self.open_branch().sprout(result, revision_id=revision_id)
638
except errors.NotBranchError:
639
pass
640
# we always want a working tree
641
WorkingTreeFormat2().initialize(result)
642
return result
643
644
645
class BzrDir4(BzrDirPreSplitOut):
646
"""A .bzr version 4 control object.
647
648
This is a deprecated format and may be removed after sept 2006.
649
"""
650
651
def create_repository(self, shared=False):
652
"""See BzrDir.create_repository."""
653
return self._format.repository_format.initialize(self, shared)
654
655
def needs_format_conversion(self, format=None):
656
"""Format 4 dirs are always in need of conversion."""
657
return True
658
659
def open_repository(self):
660
"""See BzrDir.open_repository."""
661
from bzrlib.repository import RepositoryFormat4
662
return RepositoryFormat4().open(self, _found=True)
663
664
665
class BzrDir5(BzrDirPreSplitOut):
666
"""A .bzr version 5 control object.
667
668
This is a deprecated format and may be removed after sept 2006.
669
"""
670
671
def open_repository(self):
672
"""See BzrDir.open_repository."""
673
from bzrlib.repository import RepositoryFormat5
674
return RepositoryFormat5().open(self, _found=True)
675
676
def open_workingtree(self, _unsupported=False):
677
"""See BzrDir.create_workingtree."""
678
from bzrlib.workingtree import WorkingTreeFormat2
679
return WorkingTreeFormat2().open(self, _found=True)
680
681
682
class BzrDir6(BzrDirPreSplitOut):
683
"""A .bzr version 6 control object.
684
685
This is a deprecated format and may be removed after sept 2006.
686
"""
687
688
def open_repository(self):
689
"""See BzrDir.open_repository."""
690
from bzrlib.repository import RepositoryFormat6
691
return RepositoryFormat6().open(self, _found=True)
692
693
def open_workingtree(self, _unsupported=False):
694
"""See BzrDir.create_workingtree."""
695
from bzrlib.workingtree import WorkingTreeFormat2
696
return WorkingTreeFormat2().open(self, _found=True)
697
698
699
class BzrDirMeta1(BzrDir):
700
"""A .bzr meta version 1 control object.
701
702
This is the first control object where the
703
individual aspects are really split out: there are separate repository,
704
workingtree and branch subdirectories and any subset of the three can be
705
present within a BzrDir.
706
"""
707
708
def can_convert_format(self):
709
"""See BzrDir.can_convert_format()."""
710
return True
711
712
def create_branch(self):
713
"""See BzrDir.create_branch."""
714
from bzrlib.branch import BranchFormat
715
return BranchFormat.get_default_format().initialize(self)
716
717
def create_repository(self, shared=False):
718
"""See BzrDir.create_repository."""
719
return self._format.repository_format.initialize(self, shared)
720
721
def create_workingtree(self, revision_id=None):
722
"""See BzrDir.create_workingtree."""
723
from bzrlib.workingtree import WorkingTreeFormat
724
return WorkingTreeFormat.get_default_format().initialize(self, revision_id)
725
726
def get_branch_transport(self, branch_format):
727
"""See BzrDir.get_branch_transport()."""
728
if branch_format is None:
729
return self.transport.clone('branch')
730
try:
731
branch_format.get_format_string()
732
except NotImplementedError:
733
raise errors.IncompatibleFormat(branch_format, self._format)
734
try:
735
self.transport.mkdir('branch')
736
except errors.FileExists:
737
pass
738
return self.transport.clone('branch')
739
740
def get_repository_transport(self, repository_format):
741
"""See BzrDir.get_repository_transport()."""
742
if repository_format is None:
743
return self.transport.clone('repository')
744
try:
745
repository_format.get_format_string()
746
except NotImplementedError:
747
raise errors.IncompatibleFormat(repository_format, self._format)
748
try:
749
self.transport.mkdir('repository')
750
except errors.FileExists:
751
pass
752
return self.transport.clone('repository')
753
754
def get_workingtree_transport(self, workingtree_format):
755
"""See BzrDir.get_workingtree_transport()."""
756
if workingtree_format is None:
757
return self.transport.clone('checkout')
758
try:
759
workingtree_format.get_format_string()
760
except NotImplementedError:
761
raise errors.IncompatibleFormat(workingtree_format, self._format)
762
try:
763
self.transport.mkdir('checkout')
764
except errors.FileExists:
765
pass
766
return self.transport.clone('checkout')
767
768
def needs_format_conversion(self, format=None):
769
"""See BzrDir.needs_format_conversion()."""
770
if format is None:
771
format = BzrDirFormat.get_default_format()
772
if not isinstance(self._format, format.__class__):
773
# it is not a meta dir format, conversion is needed.
774
return True
775
# we might want to push this down to the repository?
776
try:
777
if not isinstance(self.open_repository()._format,
778
format.repository_format.__class__):
779
# the repository needs an upgrade.
780
return True
781
except errors.NoRepositoryPresent:
782
pass
783
# currently there are no other possible conversions for meta1 formats.
784
return False
785
786
def open_branch(self, unsupported=False):
787
"""See BzrDir.open_branch."""
788
from bzrlib.branch import BranchFormat
789
format = BranchFormat.find_format(self)
790
self._check_supported(format, unsupported)
791
return format.open(self, _found=True)
792
793
def open_repository(self, unsupported=False):
794
"""See BzrDir.open_repository."""
795
from bzrlib.repository import RepositoryFormat
796
format = RepositoryFormat.find_format(self)
797
self._check_supported(format, unsupported)
798
return format.open(self, _found=True)
799
800
def open_workingtree(self, unsupported=False):
801
"""See BzrDir.open_workingtree."""
802
from bzrlib.workingtree import WorkingTreeFormat
803
format = WorkingTreeFormat.find_format(self)
804
self._check_supported(format, unsupported)
805
return format.open(self, _found=True)
806
807
808
class BzrDirFormat(object):
809
"""An encapsulation of the initialization and open routines for a format.
810
811
Formats provide three things:
812
* An initialization routine,
813
* a format string,
814
* an open routine.
815
816
Formats are placed in an dict by their format string for reference
817
during bzrdir opening. These should be subclasses of BzrDirFormat
818
for consistency.
819
820
Once a format is deprecated, just deprecate the initialize and open
821
methods on the format class. Do not deprecate the object, as the
822
object will be created every system load.
823
"""
824
825
_default_format = None
826
"""The default format used for new .bzr dirs."""
827
828
_formats = {}
829
"""The known formats."""
830
831
@classmethod
832
def find_format(klass, transport):
833
"""Return the format registered for URL."""
834
try:
835
format_string = transport.get(".bzr/branch-format").read()
836
return klass._formats[format_string]
837
except errors.NoSuchFile:
838
raise errors.NotBranchError(path=transport.base)
839
except KeyError:
840
raise errors.UnknownFormatError(format_string)
841
842
@classmethod
843
def get_default_format(klass):
844
"""Return the current default format."""
845
return klass._default_format
846
847
def get_format_string(self):
848
"""Return the ASCII format string that identifies this format."""
849
raise NotImplementedError(self.get_format_string)
850
851
def get_converter(self, format=None):
852
"""Return the converter to use to convert bzrdirs needing converts.
853
854
This returns a bzrlib.bzrdir.Converter object.
855
856
This should return the best upgrader to step this format towards the
857
current default format. In the case of plugins we can/shouold provide
858
some means for them to extend the range of returnable converters.
859
860
:param format: Optional format to override the default foramt of the
861
library.
862
"""
863
raise NotImplementedError(self.get_converter)
864
865
def initialize(self, url):
866
"""Create a bzr control dir at this url and return an opened copy."""
867
# Since we don't have a .bzr directory, inherit the
868
# mode from the root directory
869
t = get_transport(url)
870
temp_control = LockableFiles(t, '', TransportLock)
871
temp_control._transport.mkdir('.bzr',
872
# FIXME: RBC 20060121 dont peek under
873
# the covers
874
mode=temp_control._dir_mode)
875
file_mode = temp_control._file_mode
876
del temp_control
877
mutter('created control directory in ' + t.base)
878
control = t.clone('.bzr')
879
lock_file = 'branch-lock'
880
utf8_files = [('README',
881
"This is a Bazaar-NG control directory.\n"
882
"Do not change any files in this directory.\n"),
883
('branch-format', self.get_format_string()),
884
]
885
# NB: no need to escape relative paths that are url safe.
886
control_files = LockableFiles(control, lock_file, TransportLock)
887
control_files.create_lock()
888
control_files.lock_write()
889
try:
890
for file, content in utf8_files:
891
control_files.put_utf8(file, content)
892
finally:
893
control_files.unlock()
894
return self.open(t, _found=True)
895
896
def is_supported(self):
897
"""Is this format supported?
898
899
Supported formats must be initializable and openable.
900
Unsupported formats may not support initialization or committing or
901
some other features depending on the reason for not being supported.
902
"""
903
return True
904
905
def open(self, transport, _found=False):
906
"""Return an instance of this format for the dir transport points at.
907
908
_found is a private parameter, do not use it.
909
"""
910
if not _found:
911
assert isinstance(BzrDirFormat.find_format(transport),
912
self.__class__)
913
return self._open(transport)
914
915
def _open(self, transport):
916
"""Template method helper for opening BzrDirectories.
917
918
This performs the actual open and any additional logic or parameter
919
passing.
920
"""
921
raise NotImplementedError(self._open)
922
923
@classmethod
924
def register_format(klass, format):
925
klass._formats[format.get_format_string()] = format
926
927
@classmethod
928
def set_default_format(klass, format):
929
klass._default_format = format
930
931
def __str__(self):
932
return self.get_format_string()[:-1]
933
934
@classmethod
935
def unregister_format(klass, format):
936
assert klass._formats[format.get_format_string()] is format
937
del klass._formats[format.get_format_string()]
938
939
940
class BzrDirFormat4(BzrDirFormat):
941
"""Bzr dir format 4.
942
943
This format is a combined format for working tree, branch and repository.
944
It has:
945
- Format 1 working trees [always]
946
- Format 4 branches [always]
947
- Format 4 repositories [always]
948
949
This format is deprecated: it indexes texts using a text it which is
950
removed in format 5; write support for this format has been removed.
951
"""
952
953
def get_format_string(self):
954
"""See BzrDirFormat.get_format_string()."""
955
return "Bazaar-NG branch, format 0.0.4\n"
956
957
def get_converter(self, format=None):
958
"""See BzrDirFormat.get_converter()."""
959
# there is one and only one upgrade path here.
960
return ConvertBzrDir4To5()
961
962
def initialize(self, url):
963
"""Format 4 branches cannot be created."""
964
raise errors.UninitializableFormat(self)
965
966
def is_supported(self):
967
"""Format 4 is not supported.
968
969
It is not supported because the model changed from 4 to 5 and the
970
conversion logic is expensive - so doing it on the fly was not
971
feasible.
972
"""
973
return False
974
975
def _open(self, transport):
976
"""See BzrDirFormat._open."""
977
return BzrDir4(transport, self)
978
979
def __return_repository_format(self):
980
"""Circular import protection."""
981
from bzrlib.repository import RepositoryFormat4
982
return RepositoryFormat4(self)
983
repository_format = property(__return_repository_format)
984
985
986
class BzrDirFormat5(BzrDirFormat):
987
"""Bzr control format 5.
988
989
This format is a combined format for working tree, branch and repository.
990
It has:
991
- Format 2 working trees [always]
992
- Format 4 branches [always]
993
- Format 5 repositories [always]
994
Unhashed stores in the repository.
995
"""
996
997
def get_format_string(self):
998
"""See BzrDirFormat.get_format_string()."""
999
return "Bazaar-NG branch, format 5\n"
1000
1001
def get_converter(self, format=None):
1002
"""See BzrDirFormat.get_converter()."""
1003
# there is one and only one upgrade path here.
1004
return ConvertBzrDir5To6()
1005
1006
def initialize(self, url, _cloning=False):
1007
"""Format 5 dirs always have working tree, branch and repository.
1008
1009
Except when they are being cloned.
1010
"""
1011
from bzrlib.branch import BzrBranchFormat4
1012
from bzrlib.repository import RepositoryFormat5
1013
from bzrlib.workingtree import WorkingTreeFormat2
1014
result = super(BzrDirFormat5, self).initialize(url)
1015
RepositoryFormat5().initialize(result, _internal=True)
1016
if not _cloning:
1017
BzrBranchFormat4().initialize(result)
1018
WorkingTreeFormat2().initialize(result)
1019
return result
1020
1021
def _open(self, transport):
1022
"""See BzrDirFormat._open."""
1023
return BzrDir5(transport, self)
1024
1025
def __return_repository_format(self):
1026
"""Circular import protection."""
1027
from bzrlib.repository import RepositoryFormat5
1028
return RepositoryFormat5(self)
1029
repository_format = property(__return_repository_format)
1030
1031
1032
class BzrDirFormat6(BzrDirFormat):
1033
"""Bzr control format 6.
1034
1035
This format is a combined format for working tree, branch and repository.
1036
It has:
1037
- Format 2 working trees [always]
1038
- Format 4 branches [always]
1039
- Format 6 repositories [always]
1040
"""
1041
1042
def get_format_string(self):
1043
"""See BzrDirFormat.get_format_string()."""
1044
return "Bazaar-NG branch, format 6\n"
1045
1046
def get_converter(self, format=None):
1047
"""See BzrDirFormat.get_converter()."""
1048
# there is one and only one upgrade path here.
1049
return ConvertBzrDir6ToMeta()
1050
1051
def initialize(self, url, _cloning=False):
1052
"""Format 6 dirs always have working tree, branch and repository.
1053
1054
Except when they are being cloned.
1055
"""
1056
from bzrlib.branch import BzrBranchFormat4
1057
from bzrlib.repository import RepositoryFormat6
1058
from bzrlib.workingtree import WorkingTreeFormat2
1059
result = super(BzrDirFormat6, self).initialize(url)
1060
RepositoryFormat6().initialize(result, _internal=True)
1061
if not _cloning:
1062
BzrBranchFormat4().initialize(result)
1063
try:
1064
WorkingTreeFormat2().initialize(result)
1065
except errors.NotLocalUrl:
1066
# emulate pre-check behaviour for working tree and silently
1067
# fail.
1068
pass
1069
return result
1070
1071
def _open(self, transport):
1072
"""See BzrDirFormat._open."""
1073
return BzrDir6(transport, self)
1074
1075
def __return_repository_format(self):
1076
"""Circular import protection."""
1077
from bzrlib.repository import RepositoryFormat6
1078
return RepositoryFormat6(self)
1079
repository_format = property(__return_repository_format)
1080
1081
1082
class BzrDirMetaFormat1(BzrDirFormat):
1083
"""Bzr meta control format 1
1084
1085
This is the first format with split out working tree, branch and repository
1086
disk storage.
1087
It has:
1088
- Format 3 working trees [optional]
1089
- Format 5 branches [optional]
1090
- Format 7 repositories [optional]
1091
"""
1092
1093
def get_converter(self, format=None):
1094
"""See BzrDirFormat.get_converter()."""
1095
if format is None:
1096
format = BzrDirFormat.get_default_format()
1097
if not isinstance(self, format.__class__):
1098
# converting away from metadir is not implemented
1099
raise NotImplementedError(self.get_converter)
1100
return ConvertMetaToMeta(format)
1101
1102
def get_format_string(self):
1103
"""See BzrDirFormat.get_format_string()."""
1104
return "Bazaar-NG meta directory, format 1\n"
1105
1106
def _open(self, transport):
1107
"""See BzrDirFormat._open."""
1108
return BzrDirMeta1(transport, self)
1109
1110
def __return_repository_format(self):
1111
"""Circular import protection."""
1112
if getattr(self, '_repository_format', None):
1113
return self._repository_format
1114
from bzrlib.repository import RepositoryFormat
1115
return RepositoryFormat.get_default_format()
1116
1117
def __set_repository_format(self, value):
1118
"""Allow changint the repository format for metadir formats."""
1119
self._repository_format = value
1120
repository_format = property(__return_repository_format, __set_repository_format)
1121
1122
1123
BzrDirFormat.register_format(BzrDirFormat4())
1124
BzrDirFormat.register_format(BzrDirFormat5())
1125
BzrDirFormat.register_format(BzrDirMetaFormat1())
1126
__default_format = BzrDirFormat6()
1127
BzrDirFormat.register_format(__default_format)
1128
BzrDirFormat.set_default_format(__default_format)
1129
1130
1131
class BzrDirTestProviderAdapter(object):
1132
"""A tool to generate a suite testing multiple bzrdir formats at once.
1133
1134
This is done by copying the test once for each transport and injecting
1135
the transport_server, transport_readonly_server, and bzrdir_format
1136
classes into each copy. Each copy is also given a new id() to make it
1137
easy to identify.
1138
"""
1139
1140
def __init__(self, transport_server, transport_readonly_server, formats):
1141
self._transport_server = transport_server
1142
self._transport_readonly_server = transport_readonly_server
1143
self._formats = formats
1144
1145
def adapt(self, test):
1146
result = TestSuite()
1147
for format in self._formats:
1148
new_test = deepcopy(test)
1149
new_test.transport_server = self._transport_server
1150
new_test.transport_readonly_server = self._transport_readonly_server
1151
new_test.bzrdir_format = format
1152
def make_new_test_id():
1153
new_id = "%s(%s)" % (new_test.id(), format.__class__.__name__)
1154
return lambda: new_id
1155
new_test.id = make_new_test_id()
1156
result.addTest(new_test)
1157
return result
1158
1159
1160
class ScratchDir(BzrDir6):
1161
"""Special test class: a bzrdir that cleans up itself..
1162
1163
>>> d = ScratchDir()
1164
>>> base = d.transport.base
1165
>>> isdir(base)
1166
True
1167
>>> b.transport.__del__()
1168
>>> isdir(base)
1169
False
1170
"""
1171
1172
def __init__(self, files=[], dirs=[], transport=None):
1173
"""Make a test branch.
1174
1175
This creates a temporary directory and runs init-tree in it.
1176
1177
If any files are listed, they are created in the working copy.
1178
"""
1179
if transport is None:
1180
transport = bzrlib.transport.local.ScratchTransport()
1181
# local import for scope restriction
1182
BzrDirFormat6().initialize(transport.base)
1183
super(ScratchDir, self).__init__(transport, BzrDirFormat6())
1184
self.create_repository()
1185
self.create_branch()
1186
self.create_workingtree()
1187
else:
1188
super(ScratchDir, self).__init__(transport, BzrDirFormat6())
1189
1190
# BzrBranch creates a clone to .bzr and then forgets about the
1191
# original transport. A ScratchTransport() deletes itself and
1192
# everything underneath it when it goes away, so we need to
1193
# grab a local copy to prevent that from happening
1194
self._transport = transport
1195
1196
for d in dirs:
1197
self._transport.mkdir(d)
1198
1199
for f in files:
1200
self._transport.put(f, 'content of %s' % f)
1201
1202
def clone(self):
1203
"""
1204
>>> orig = ScratchDir(files=["file1", "file2"])
1205
>>> os.listdir(orig.base)
1206
[u'.bzr', u'file1', u'file2']
1207
>>> clone = orig.clone()
1208
>>> if os.name != 'nt':
1209
... os.path.samefile(orig.base, clone.base)
1210
... else:
1211
... orig.base == clone.base
1212
...
1213
False
1214
>>> os.listdir(clone.base)
1215
[u'.bzr', u'file1', u'file2']
1216
"""
1217
from shutil import copytree
1218
from bzrlib.osutils import mkdtemp
1219
base = mkdtemp()
1220
os.rmdir(base)
1221
copytree(self.base, base, symlinks=True)
1222
return ScratchDir(
1223
transport=bzrlib.transport.local.ScratchTransport(base))
1224
1225
1226
class Converter(object):
1227
"""Converts a disk format object from one format to another."""
1228
1229
def convert(self, to_convert, pb):
1230
"""Perform the conversion of to_convert, giving feedback via pb.
1231
1232
:param to_convert: The disk object to convert.
1233
:param pb: a progress bar to use for progress information.
1234
"""
1235
1236
def step(self, message):
1237
"""Update the pb by a step."""
1238
self.count +=1
1239
self.pb.update(message, self.count, self.total)
1240
1241
1242
class ConvertBzrDir4To5(Converter):
1243
"""Converts format 4 bzr dirs to format 5."""
1244
1245
def __init__(self):
1246
super(ConvertBzrDir4To5, self).__init__()
1247
self.converted_revs = set()
1248
self.absent_revisions = set()
1249
self.text_count = 0
1250
self.revisions = {}
1251
1252
def convert(self, to_convert, pb):
1253
"""See Converter.convert()."""
1254
self.bzrdir = to_convert
1255
self.pb = pb
1256
self.pb.note('starting upgrade from format 4 to 5')
1257
if isinstance(self.bzrdir.transport, LocalTransport):
1258
self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
1259
self._convert_to_weaves()
1260
return BzrDir.open(self.bzrdir.root_transport.base)
1261
1262
def _convert_to_weaves(self):
1263
self.pb.note('note: upgrade may be faster if all store files are ungzipped first')
1264
try:
1265
# TODO permissions
1266
stat = self.bzrdir.transport.stat('weaves')
1267
if not S_ISDIR(stat.st_mode):
1268
self.bzrdir.transport.delete('weaves')
1269
self.bzrdir.transport.mkdir('weaves')
1270
except errors.NoSuchFile:
1271
self.bzrdir.transport.mkdir('weaves')
1272
self.inv_weave = Weave('inventory')
1273
# holds in-memory weaves for all files
1274
self.text_weaves = {}
1275
self.bzrdir.transport.delete('branch-format')
1276
self.branch = self.bzrdir.open_branch()
1277
self._convert_working_inv()
1278
rev_history = self.branch.revision_history()
1279
# to_read is a stack holding the revisions we still need to process;
1280
# appending to it adds new highest-priority revisions
1281
self.known_revisions = set(rev_history)
1282
self.to_read = rev_history[-1:]
1283
while self.to_read:
1284
rev_id = self.to_read.pop()
1285
if (rev_id not in self.revisions
1286
and rev_id not in self.absent_revisions):
1287
self._load_one_rev(rev_id)
1288
self.pb.clear()
1289
to_import = self._make_order()
1290
for i, rev_id in enumerate(to_import):
1291
self.pb.update('converting revision', i, len(to_import))
1292
self._convert_one_rev(rev_id)
1293
self.pb.clear()
1294
self._write_all_weaves()
1295
self._write_all_revs()
1296
self.pb.note('upgraded to weaves:')
1297
self.pb.note(' %6d revisions and inventories', len(self.revisions))
1298
self.pb.note(' %6d revisions not present', len(self.absent_revisions))
1299
self.pb.note(' %6d texts', self.text_count)
1300
self._cleanup_spare_files_after_format4()
1301
self.branch.control_files.put_utf8('branch-format', BzrDirFormat5().get_format_string())
1302
1303
def _cleanup_spare_files_after_format4(self):
1304
# FIXME working tree upgrade foo.
1305
for n in 'merged-patches', 'pending-merged-patches':
1306
try:
1307
## assert os.path.getsize(p) == 0
1308
self.bzrdir.transport.delete(n)
1309
except errors.NoSuchFile:
1310
pass
1311
self.bzrdir.transport.delete_tree('inventory-store')
1312
self.bzrdir.transport.delete_tree('text-store')
1313
1314
def _convert_working_inv(self):
1315
inv = serializer_v4.read_inventory(self.branch.control_files.get('inventory'))
1316
new_inv_xml = serializer_v5.write_inventory_to_string(inv)
1317
# FIXME inventory is a working tree change.
1318
self.branch.control_files.put('inventory', new_inv_xml)
1319
1320
def _write_all_weaves(self):
1321
controlweaves = WeaveStore(self.bzrdir.transport, prefixed=False)
1322
weave_transport = self.bzrdir.transport.clone('weaves')
1323
weaves = WeaveStore(weave_transport, prefixed=False)
1324
transaction = PassThroughTransaction()
1325
1326
controlweaves.put_weave('inventory', self.inv_weave, transaction)
1327
i = 0
1328
try:
1329
for file_id, file_weave in self.text_weaves.items():
1330
self.pb.update('writing weave', i, len(self.text_weaves))
1331
weaves.put_weave(file_id, file_weave, transaction)
1332
i += 1
1333
finally:
1334
self.pb.clear()
1335
1336
def _write_all_revs(self):
1337
"""Write all revisions out in new form."""
1338
self.bzrdir.transport.delete_tree('revision-store')
1339
self.bzrdir.transport.mkdir('revision-store')
1340
revision_transport = self.bzrdir.transport.clone('revision-store')
1341
# TODO permissions
1342
revision_store = TextStore(revision_transport,
1343
prefixed=False,
1344
compressed=True)
1345
try:
1346
for i, rev_id in enumerate(self.converted_revs):
1347
self.pb.update('write revision', i, len(self.converted_revs))
1348
rev_tmp = StringIO()
1349
serializer_v5.write_revision(self.revisions[rev_id], rev_tmp)
1350
rev_tmp.seek(0)
1351
revision_store.add(rev_tmp, rev_id)
1352
finally:
1353
self.pb.clear()
1354
1355
def _load_one_rev(self, rev_id):
1356
"""Load a revision object into memory.
1357
1358
Any parents not either loaded or abandoned get queued to be
1359
loaded."""
1360
self.pb.update('loading revision',
1361
len(self.revisions),
1362
len(self.known_revisions))
1363
if not self.branch.repository.revision_store.has_id(rev_id):
1364
self.pb.clear()
1365
self.pb.note('revision {%s} not present in branch; '
1366
'will be converted as a ghost',
1367
rev_id)
1368
self.absent_revisions.add(rev_id)
1369
else:
1370
rev_xml = self.branch.repository.revision_store.get(rev_id).read()
1371
rev = serializer_v4.read_revision_from_string(rev_xml)
1372
for parent_id in rev.parent_ids:
1373
self.known_revisions.add(parent_id)
1374
self.to_read.append(parent_id)
1375
self.revisions[rev_id] = rev
1376
1377
def _load_old_inventory(self, rev_id):
1378
assert rev_id not in self.converted_revs
1379
old_inv_xml = self.branch.repository.inventory_store.get(rev_id).read()
1380
inv = serializer_v4.read_inventory_from_string(old_inv_xml)
1381
rev = self.revisions[rev_id]
1382
if rev.inventory_sha1:
1383
assert rev.inventory_sha1 == sha_string(old_inv_xml), \
1384
'inventory sha mismatch for {%s}' % rev_id
1385
return inv
1386
1387
def _load_updated_inventory(self, rev_id):
1388
assert rev_id in self.converted_revs
1389
inv_xml = self.inv_weave.get_text(rev_id)
1390
inv = serializer_v5.read_inventory_from_string(inv_xml)
1391
return inv
1392
1393
def _convert_one_rev(self, rev_id):
1394
"""Convert revision and all referenced objects to new format."""
1395
rev = self.revisions[rev_id]
1396
inv = self._load_old_inventory(rev_id)
1397
present_parents = [p for p in rev.parent_ids
1398
if p not in self.absent_revisions]
1399
self._convert_revision_contents(rev, inv, present_parents)
1400
self._store_new_weave(rev, inv, present_parents)
1401
self.converted_revs.add(rev_id)
1402
1403
def _store_new_weave(self, rev, inv, present_parents):
1404
# the XML is now updated with text versions
1405
if __debug__:
1406
for file_id in inv:
1407
ie = inv[file_id]
1408
if ie.kind == 'root_directory':
1409
continue
1410
assert hasattr(ie, 'revision'), \
1411
'no revision on {%s} in {%s}' % \
1412
(file_id, rev.revision_id)
1413
new_inv_xml = serializer_v5.write_inventory_to_string(inv)
1414
new_inv_sha1 = sha_string(new_inv_xml)
1415
self.inv_weave.add(rev.revision_id,
1416
present_parents,
1417
new_inv_xml.splitlines(True),
1418
new_inv_sha1)
1419
rev.inventory_sha1 = new_inv_sha1
1420
1421
def _convert_revision_contents(self, rev, inv, present_parents):
1422
"""Convert all the files within a revision.
1423
1424
Also upgrade the inventory to refer to the text revision ids."""
1425
rev_id = rev.revision_id
1426
mutter('converting texts of revision {%s}',
1427
rev_id)
1428
parent_invs = map(self._load_updated_inventory, present_parents)
1429
for file_id in inv:
1430
ie = inv[file_id]
1431
self._convert_file_version(rev, ie, parent_invs)
1432
1433
def _convert_file_version(self, rev, ie, parent_invs):
1434
"""Convert one version of one file.
1435
1436
The file needs to be added into the weave if it is a merge
1437
of >=2 parents or if it's changed from its parent.
1438
"""
1439
if ie.kind == 'root_directory':
1440
return
1441
file_id = ie.file_id
1442
rev_id = rev.revision_id
1443
w = self.text_weaves.get(file_id)
1444
if w is None:
1445
w = Weave(file_id)
1446
self.text_weaves[file_id] = w
1447
text_changed = False
1448
previous_entries = ie.find_previous_heads(parent_invs, w)
1449
for old_revision in previous_entries:
1450
# if this fails, its a ghost ?
1451
assert old_revision in self.converted_revs
1452
self.snapshot_ie(previous_entries, ie, w, rev_id)
1453
del ie.text_id
1454
assert getattr(ie, 'revision', None) is not None
1455
1456
def snapshot_ie(self, previous_revisions, ie, w, rev_id):
1457
# TODO: convert this logic, which is ~= snapshot to
1458
# a call to:. This needs the path figured out. rather than a work_tree
1459
# a v4 revision_tree can be given, or something that looks enough like
1460
# one to give the file content to the entry if it needs it.
1461
# and we need something that looks like a weave store for snapshot to
1462
# save against.
1463
#ie.snapshot(rev, PATH, previous_revisions, REVISION_TREE, InMemoryWeaveStore(self.text_weaves))
1464
if len(previous_revisions) == 1:
1465
previous_ie = previous_revisions.values()[0]
1466
if ie._unchanged(previous_ie):
1467
ie.revision = previous_ie.revision
1468
return
1469
parent_indexes = map(w.lookup, previous_revisions)
1470
if ie.has_text():
1471
text = self.branch.repository.text_store.get(ie.text_id)
1472
file_lines = text.readlines()
1473
assert sha_strings(file_lines) == ie.text_sha1
1474
assert sum(map(len, file_lines)) == ie.text_size
1475
w.add(rev_id, parent_indexes, file_lines, ie.text_sha1)
1476
self.text_count += 1
1477
else:
1478
w.add(rev_id, parent_indexes, [], None)
1479
ie.revision = rev_id
1480
1481
def _make_order(self):
1482
"""Return a suitable order for importing revisions.
1483
1484
The order must be such that an revision is imported after all
1485
its (present) parents.
1486
"""
1487
todo = set(self.revisions.keys())
1488
done = self.absent_revisions.copy()
1489
order = []
1490
while todo:
1491
# scan through looking for a revision whose parents
1492
# are all done
1493
for rev_id in sorted(list(todo)):
1494
rev = self.revisions[rev_id]
1495
parent_ids = set(rev.parent_ids)
1496
if parent_ids.issubset(done):
1497
# can take this one now
1498
order.append(rev_id)
1499
todo.remove(rev_id)
1500
done.add(rev_id)
1501
return order
1502
1503
1504
class ConvertBzrDir5To6(Converter):
1505
"""Converts format 5 bzr dirs to format 6."""
1506
1507
def convert(self, to_convert, pb):
1508
"""See Converter.convert()."""
1509
self.bzrdir = to_convert
1510
self.pb = pb
1511
self.pb.note('starting upgrade from format 5 to 6')
1512
self._convert_to_prefixed()
1513
return BzrDir.open(self.bzrdir.root_transport.base)
1514
1515
def _convert_to_prefixed(self):
1516
from bzrlib.store import hash_prefix
1517
self.bzrdir.transport.delete('branch-format')
1518
for store_name in ["weaves", "revision-store"]:
1519
self.pb.note("adding prefixes to %s" % store_name)
1520
store_transport = self.bzrdir.transport.clone(store_name)
1521
for filename in store_transport.list_dir('.'):
1522
if (filename.endswith(".weave") or
1523
filename.endswith(".gz") or
1524
filename.endswith(".sig")):
1525
file_id = os.path.splitext(filename)[0]
1526
else:
1527
file_id = filename
1528
prefix_dir = hash_prefix(file_id)
1529
# FIXME keep track of the dirs made RBC 20060121
1530
try:
1531
store_transport.move(filename, prefix_dir + '/' + filename)
1532
except errors.NoSuchFile: # catches missing dirs strangely enough
1533
store_transport.mkdir(prefix_dir)
1534
store_transport.move(filename, prefix_dir + '/' + filename)
1535
self.bzrdir._control_files.put_utf8('branch-format', BzrDirFormat6().get_format_string())
1536
1537
1538
class ConvertBzrDir6ToMeta(Converter):
1539
"""Converts format 6 bzr dirs to metadirs."""
1540
1541
def convert(self, to_convert, pb):
1542
"""See Converter.convert()."""
1543
self.bzrdir = to_convert
1544
self.pb = pb
1545
self.count = 0
1546
self.total = 20 # the steps we know about
1547
self.garbage_inventories = []
1548
1549
self.pb.note('starting upgrade from format 6 to metadir')
1550
self.bzrdir._control_files.put_utf8('branch-format', "Converting to format 6")
1551
# its faster to move specific files around than to open and use the apis...
1552
# first off, nuke ancestry.weave, it was never used.
1553
try:
1554
self.step('Removing ancestry.weave')
1555
self.bzrdir.transport.delete('ancestry.weave')
1556
except errors.NoSuchFile:
1557
pass
1558
# find out whats there
1559
self.step('Finding branch files')
1560
last_revision = self.bzrdir.open_workingtree().last_revision()
1561
bzrcontents = self.bzrdir.transport.list_dir('.')
1562
for name in bzrcontents:
1563
if name.startswith('basis-inventory.'):
1564
self.garbage_inventories.append(name)
1565
# create new directories for repository, working tree and branch
1566
dir_mode = self.bzrdir._control_files._dir_mode
1567
self.file_mode = self.bzrdir._control_files._file_mode
1568
repository_names = [('inventory.weave', True),
1569
('revision-store', True),
1570
('weaves', True)]
1571
self.step('Upgrading repository ')
1572
self.bzrdir.transport.mkdir('repository', mode=dir_mode)
1573
self.make_lock('repository')
1574
# we hard code the formats here because we are converting into
1575
# the meta format. The meta format upgrader can take this to a
1576
# future format within each component.
1577
self.put_format('repository', bzrlib.repository.RepositoryFormat7())
1578
for entry in repository_names:
1579
self.move_entry('repository', entry)
1580
1581
self.step('Upgrading branch ')
1582
self.bzrdir.transport.mkdir('branch', mode=dir_mode)
1583
self.make_lock('branch')
1584
self.put_format('branch', bzrlib.branch.BzrBranchFormat5())
1585
branch_files = [('revision-history', True),
1586
('branch-name', True),
1587
('parent', False)]
1588
for entry in branch_files:
1589
self.move_entry('branch', entry)
1590
1591
self.step('Upgrading working tree')
1592
self.bzrdir.transport.mkdir('checkout', mode=dir_mode)
1593
self.make_lock('checkout')
1594
self.put_format('checkout', bzrlib.workingtree.WorkingTreeFormat3())
1595
self.bzrdir.transport.delete_multi(self.garbage_inventories, self.pb)
1596
checkout_files = [('pending-merges', True),
1597
('inventory', True),
1598
('stat-cache', False)]
1599
for entry in checkout_files:
1600
self.move_entry('checkout', entry)
1601
if last_revision is not None:
1602
self.bzrdir._control_files.put_utf8('checkout/last-revision',
1603
last_revision)
1604
self.bzrdir._control_files.put_utf8('branch-format', BzrDirMetaFormat1().get_format_string())
1605
return BzrDir.open(self.bzrdir.root_transport.base)
1606
1607
def make_lock(self, name):
1608
"""Make a lock for the new control dir name."""
1609
self.step('Make %s lock' % name)
1610
self.bzrdir.transport.put('%s/lock' % name, StringIO(), mode=self.file_mode)
1611
1612
def move_entry(self, new_dir, entry):
1613
"""Move then entry name into new_dir."""
1614
name = entry[0]
1615
mandatory = entry[1]
1616
self.step('Moving %s' % name)
1617
try:
1618
self.bzrdir.transport.move(name, '%s/%s' % (new_dir, name))
1619
except errors.NoSuchFile:
1620
if mandatory:
1621
raise
1622
1623
def put_format(self, dirname, format):
1624
self.bzrdir._control_files.put_utf8('%s/format' % dirname, format.get_format_string())
1625
1626
1627
class ConvertMetaToMeta(Converter):
1628
"""Converts the components of metadirs."""
1629
1630
def __init__(self, target_format):
1631
"""Create a metadir to metadir converter.
1632
1633
:param target_format: The final metadir format that is desired.
1634
"""
1635
self.target_format = target_format
1636
1637
def convert(self, to_convert, pb):
1638
"""See Converter.convert()."""
1639
self.bzrdir = to_convert
1640
self.pb = pb
1641
self.count = 0
1642
self.total = 1
1643
self.step('checking repository format')
1644
try:
1645
repo = self.bzrdir.open_repository()
1646
except errors.NoRepositoryPresent:
1647
pass
1648
else:
1649
if not isinstance(repo._format, self.target_format.repository_format.__class__):
1650
from bzrlib.repository import CopyConverter
1651
self.pb.note('starting repository conversion')
1652
converter = CopyConverter(self.target_format.repository_format)
1653
converter.convert(repo, pb)
1654
return to_convert
Loggerhead is a web-based interface for Breezy
Version: 2.0.1