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