« back to all changes in this revision
Viewing changes to bzrlib/bzrdir.py
- browse files at revision 1662.1.4
- compare with another revision
- download diff
- download tarball
- view history from revision 1662.1.4
- Committer: Martin Pool
- Date: 2006-04-18 04:38:44 UTC
- mto: This revision was merged to the branch mainline in revision 1670.
- Revision ID: mbp@sourcefrog.net-20060418043844-dbaac5bdecaed3d1
Clear out BRANCH.TODO - most of them are done now
- files added:
- .rsyncexclude
- 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
- bzrlib/util/elementtree
- bzrlib/util/urlgrabber
- contrib
- contrib/bash
- contrib/emacs
- contrib/zsh
- tools
- tools/doc_generate
- files removed:
- bzrlib/tests.py
- files renamed:
- bzrlib/store.py => bzrlib/store/__init__.py
- bzrlib/xml.py => bzrlib/xml_serializer.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_for_clone(url)
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_for_clone(url)
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_format_description(self):
874
"""Return the short description for this format."""
875
raise NotImplementedError(self.get_format_description)
876
877
def get_converter(self, format=None):
878
"""Return the converter to use to convert bzrdirs needing converts.
879
880
This returns a bzrlib.bzrdir.Converter object.
881
882
This should return the best upgrader to step this format towards the
883
current default format. In the case of plugins we can/shouold provide
884
some means for them to extend the range of returnable converters.
885
886
:param format: Optional format to override the default foramt of the
887
library.
888
"""
889
raise NotImplementedError(self.get_converter)
890
891
def initialize(self, url):
892
"""Create a bzr control dir at this url and return an opened copy.
893
894
Subclasses should typically override initialize_on_transport
895
instead of this method.
896
"""
897
return self.initialize_on_transport(get_transport(url))
898
899
def initialize_on_transport(self, transport):
900
"""Initialize a new bzrdir in the base directory of a Transport."""
901
# Since we don'transport have a .bzr directory, inherit the
902
# mode from the root directory
903
temp_control = LockableFiles(transport, '', TransportLock)
904
temp_control._transport.mkdir('.bzr',
905
# FIXME: RBC 20060121 dont peek under
906
# the covers
907
mode=temp_control._dir_mode)
908
file_mode = temp_control._file_mode
909
del temp_control
910
mutter('created control directory in ' + transport.base)
911
control = transport.clone('.bzr')
912
utf8_files = [('README',
913
"This is a Bazaar-NG control directory.\n"
914
"Do not change any files in this directory.\n"),
915
('branch-format', self.get_format_string()),
916
]
917
# NB: no need to escape relative paths that are url safe.
918
control_files = LockableFiles(control, self._lock_file_name,
919
self._lock_class)
920
control_files.create_lock()
921
control_files.lock_write()
922
try:
923
for file, content in utf8_files:
924
control_files.put_utf8(file, content)
925
finally:
926
control_files.unlock()
927
return self.open(transport, _found=True)
928
929
def is_supported(self):
930
"""Is this format supported?
931
932
Supported formats must be initializable and openable.
933
Unsupported formats may not support initialization or committing or
934
some other features depending on the reason for not being supported.
935
"""
936
return True
937
938
def open(self, transport, _found=False):
939
"""Return an instance of this format for the dir transport points at.
940
941
_found is a private parameter, do not use it.
942
"""
943
if not _found:
944
assert isinstance(BzrDirFormat.find_format(transport),
945
self.__class__)
946
return self._open(transport)
947
948
def _open(self, transport):
949
"""Template method helper for opening BzrDirectories.
950
951
This performs the actual open and any additional logic or parameter
952
passing.
953
"""
954
raise NotImplementedError(self._open)
955
956
@classmethod
957
def register_format(klass, format):
958
klass._formats[format.get_format_string()] = format
959
960
@classmethod
961
def set_default_format(klass, format):
962
klass._default_format = format
963
964
def __str__(self):
965
return self.get_format_string()[:-1]
966
967
@classmethod
968
def unregister_format(klass, format):
969
assert klass._formats[format.get_format_string()] is format
970
del klass._formats[format.get_format_string()]
971
972
973
class BzrDirFormat4(BzrDirFormat):
974
"""Bzr dir format 4.
975
976
This format is a combined format for working tree, branch and repository.
977
It has:
978
- Format 1 working trees [always]
979
- Format 4 branches [always]
980
- Format 4 repositories [always]
981
982
This format is deprecated: it indexes texts using a text it which is
983
removed in format 5; write support for this format has been removed.
984
"""
985
986
_lock_class = TransportLock
987
988
def get_format_string(self):
989
"""See BzrDirFormat.get_format_string()."""
990
return "Bazaar-NG branch, format 0.0.4\n"
991
992
def get_format_description(self):
993
"""See BzrDirFormat.get_format_description()."""
994
return "All-in-one format 4"
995
996
def get_converter(self, format=None):
997
"""See BzrDirFormat.get_converter()."""
998
# there is one and only one upgrade path here.
999
return ConvertBzrDir4To5()
1000
1001
def initialize_on_transport(self, transport):
1002
"""Format 4 branches cannot be created."""
1003
raise errors.UninitializableFormat(self)
1004
1005
def is_supported(self):
1006
"""Format 4 is not supported.
1007
1008
It is not supported because the model changed from 4 to 5 and the
1009
conversion logic is expensive - so doing it on the fly was not
1010
feasible.
1011
"""
1012
return False
1013
1014
def _open(self, transport):
1015
"""See BzrDirFormat._open."""
1016
return BzrDir4(transport, self)
1017
1018
def __return_repository_format(self):
1019
"""Circular import protection."""
1020
from bzrlib.repository import RepositoryFormat4
1021
return RepositoryFormat4(self)
1022
repository_format = property(__return_repository_format)
1023
1024
1025
class BzrDirFormat5(BzrDirFormat):
1026
"""Bzr control format 5.
1027
1028
This format is a combined format for working tree, branch and repository.
1029
It has:
1030
- Format 2 working trees [always]
1031
- Format 4 branches [always]
1032
- Format 5 repositories [always]
1033
Unhashed stores in the repository.
1034
"""
1035
1036
_lock_class = TransportLock
1037
1038
def get_format_string(self):
1039
"""See BzrDirFormat.get_format_string()."""
1040
return "Bazaar-NG branch, format 5\n"
1041
1042
def get_format_description(self):
1043
"""See BzrDirFormat.get_format_description()."""
1044
return "All-in-one format 5"
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 ConvertBzrDir5To6()
1050
1051
def _initialize_for_clone(self, url):
1052
return self.initialize_on_transport(get_transport(url), _cloning=True)
1053
1054
def initialize_on_transport(self, transport, _cloning=False):
1055
"""Format 5 dirs always have working tree, branch and repository.
1056
1057
Except when they are being cloned.
1058
"""
1059
from bzrlib.branch import BzrBranchFormat4
1060
from bzrlib.repository import RepositoryFormat5
1061
from bzrlib.workingtree import WorkingTreeFormat2
1062
result = (super(BzrDirFormat5, self).initialize_on_transport(transport))
1063
RepositoryFormat5().initialize(result, _internal=True)
1064
if not _cloning:
1065
BzrBranchFormat4().initialize(result)
1066
WorkingTreeFormat2().initialize(result)
1067
return result
1068
1069
def _open(self, transport):
1070
"""See BzrDirFormat._open."""
1071
return BzrDir5(transport, self)
1072
1073
def __return_repository_format(self):
1074
"""Circular import protection."""
1075
from bzrlib.repository import RepositoryFormat5
1076
return RepositoryFormat5(self)
1077
repository_format = property(__return_repository_format)
1078
1079
1080
class BzrDirFormat6(BzrDirFormat):
1081
"""Bzr control format 6.
1082
1083
This format is a combined format for working tree, branch and repository.
1084
It has:
1085
- Format 2 working trees [always]
1086
- Format 4 branches [always]
1087
- Format 6 repositories [always]
1088
"""
1089
1090
_lock_class = TransportLock
1091
1092
def get_format_string(self):
1093
"""See BzrDirFormat.get_format_string()."""
1094
return "Bazaar-NG branch, format 6\n"
1095
1096
def get_format_description(self):
1097
"""See BzrDirFormat.get_format_description()."""
1098
return "All-in-one format 6"
1099
1100
def get_converter(self, format=None):
1101
"""See BzrDirFormat.get_converter()."""
1102
# there is one and only one upgrade path here.
1103
return ConvertBzrDir6ToMeta()
1104
1105
def _initialize_for_clone(self, url):
1106
return self.initialize_on_transport(get_transport(url), _cloning=True)
1107
1108
def initialize_on_transport(self, transport, _cloning=False):
1109
"""Format 6 dirs always have working tree, branch and repository.
1110
1111
Except when they are being cloned.
1112
"""
1113
from bzrlib.branch import BzrBranchFormat4
1114
from bzrlib.repository import RepositoryFormat6
1115
from bzrlib.workingtree import WorkingTreeFormat2
1116
result = super(BzrDirFormat6, self).initialize_on_transport(transport)
1117
RepositoryFormat6().initialize(result, _internal=True)
1118
if not _cloning:
1119
BzrBranchFormat4().initialize(result)
1120
try:
1121
WorkingTreeFormat2().initialize(result)
1122
except errors.NotLocalUrl:
1123
# emulate pre-check behaviour for working tree and silently
1124
# fail.
1125
pass
1126
return result
1127
1128
def _open(self, transport):
1129
"""See BzrDirFormat._open."""
1130
return BzrDir6(transport, self)
1131
1132
def __return_repository_format(self):
1133
"""Circular import protection."""
1134
from bzrlib.repository import RepositoryFormat6
1135
return RepositoryFormat6(self)
1136
repository_format = property(__return_repository_format)
1137
1138
1139
class BzrDirMetaFormat1(BzrDirFormat):
1140
"""Bzr meta control format 1
1141
1142
This is the first format with split out working tree, branch and repository
1143
disk storage.
1144
It has:
1145
- Format 3 working trees [optional]
1146
- Format 5 branches [optional]
1147
- Format 7 repositories [optional]
1148
"""
1149
1150
_lock_class = LockDir
1151
1152
def get_converter(self, format=None):
1153
"""See BzrDirFormat.get_converter()."""
1154
if format is None:
1155
format = BzrDirFormat.get_default_format()
1156
if not isinstance(self, format.__class__):
1157
# converting away from metadir is not implemented
1158
raise NotImplementedError(self.get_converter)
1159
return ConvertMetaToMeta(format)
1160
1161
def get_format_string(self):
1162
"""See BzrDirFormat.get_format_string()."""
1163
return "Bazaar-NG meta directory, format 1\n"
1164
1165
def get_format_description(self):
1166
"""See BzrDirFormat.get_format_description()."""
1167
return "Meta directory format 1"
1168
1169
def _open(self, transport):
1170
"""See BzrDirFormat._open."""
1171
return BzrDirMeta1(transport, self)
1172
1173
def __return_repository_format(self):
1174
"""Circular import protection."""
1175
if getattr(self, '_repository_format', None):
1176
return self._repository_format
1177
from bzrlib.repository import RepositoryFormat
1178
return RepositoryFormat.get_default_format()
1179
1180
def __set_repository_format(self, value):
1181
"""Allow changint the repository format for metadir formats."""
1182
self._repository_format = value
1183
1184
repository_format = property(__return_repository_format, __set_repository_format)
1185
1186
1187
BzrDirFormat.register_format(BzrDirFormat4())
1188
BzrDirFormat.register_format(BzrDirFormat5())
1189
BzrDirFormat.register_format(BzrDirMetaFormat1())
1190
__default_format = BzrDirFormat6()
1191
BzrDirFormat.register_format(__default_format)
1192
BzrDirFormat.set_default_format(__default_format)
1193
1194
1195
class BzrDirTestProviderAdapter(object):
1196
"""A tool to generate a suite testing multiple bzrdir formats at once.
1197
1198
This is done by copying the test once for each transport and injecting
1199
the transport_server, transport_readonly_server, and bzrdir_format
1200
classes into each copy. Each copy is also given a new id() to make it
1201
easy to identify.
1202
"""
1203
1204
def __init__(self, transport_server, transport_readonly_server, formats):
1205
self._transport_server = transport_server
1206
self._transport_readonly_server = transport_readonly_server
1207
self._formats = formats
1208
1209
def adapt(self, test):
1210
result = TestSuite()
1211
for format in self._formats:
1212
new_test = deepcopy(test)
1213
new_test.transport_server = self._transport_server
1214
new_test.transport_readonly_server = self._transport_readonly_server
1215
new_test.bzrdir_format = format
1216
def make_new_test_id():
1217
new_id = "%s(%s)" % (new_test.id(), format.__class__.__name__)
1218
return lambda: new_id
1219
new_test.id = make_new_test_id()
1220
result.addTest(new_test)
1221
return result
1222
1223
1224
class ScratchDir(BzrDir6):
1225
"""Special test class: a bzrdir that cleans up itself..
1226
1227
>>> d = ScratchDir()
1228
>>> base = d.transport.base
1229
>>> isdir(base)
1230
True
1231
>>> b.transport.__del__()
1232
>>> isdir(base)
1233
False
1234
"""
1235
1236
def __init__(self, files=[], dirs=[], transport=None):
1237
"""Make a test branch.
1238
1239
This creates a temporary directory and runs init-tree in it.
1240
1241
If any files are listed, they are created in the working copy.
1242
"""
1243
if transport is None:
1244
transport = bzrlib.transport.local.ScratchTransport()
1245
# local import for scope restriction
1246
BzrDirFormat6().initialize(transport.base)
1247
super(ScratchDir, self).__init__(transport, BzrDirFormat6())
1248
self.create_repository()
1249
self.create_branch()
1250
self.create_workingtree()
1251
else:
1252
super(ScratchDir, self).__init__(transport, BzrDirFormat6())
1253
1254
# BzrBranch creates a clone to .bzr and then forgets about the
1255
# original transport. A ScratchTransport() deletes itself and
1256
# everything underneath it when it goes away, so we need to
1257
# grab a local copy to prevent that from happening
1258
self._transport = transport
1259
1260
for d in dirs:
1261
self._transport.mkdir(d)
1262
1263
for f in files:
1264
self._transport.put(f, 'content of %s' % f)
1265
1266
def clone(self):
1267
"""
1268
>>> orig = ScratchDir(files=["file1", "file2"])
1269
>>> os.listdir(orig.base)
1270
[u'.bzr', u'file1', u'file2']
1271
>>> clone = orig.clone()
1272
>>> if os.name != 'nt':
1273
... os.path.samefile(orig.base, clone.base)
1274
... else:
1275
... orig.base == clone.base
1276
...
1277
False
1278
>>> os.listdir(clone.base)
1279
[u'.bzr', u'file1', u'file2']
1280
"""
1281
from shutil import copytree
1282
from bzrlib.osutils import mkdtemp
1283
base = mkdtemp()
1284
os.rmdir(base)
1285
copytree(self.base, base, symlinks=True)
1286
return ScratchDir(
1287
transport=bzrlib.transport.local.ScratchTransport(base))
1288
1289
1290
class Converter(object):
1291
"""Converts a disk format object from one format to another."""
1292
1293
def convert(self, to_convert, pb):
1294
"""Perform the conversion of to_convert, giving feedback via pb.
1295
1296
:param to_convert: The disk object to convert.
1297
:param pb: a progress bar to use for progress information.
1298
"""
1299
1300
def step(self, message):
1301
"""Update the pb by a step."""
1302
self.count +=1
1303
self.pb.update(message, self.count, self.total)
1304
1305
1306
class ConvertBzrDir4To5(Converter):
1307
"""Converts format 4 bzr dirs to format 5."""
1308
1309
def __init__(self):
1310
super(ConvertBzrDir4To5, self).__init__()
1311
self.converted_revs = set()
1312
self.absent_revisions = set()
1313
self.text_count = 0
1314
self.revisions = {}
1315
1316
def convert(self, to_convert, pb):
1317
"""See Converter.convert()."""
1318
self.bzrdir = to_convert
1319
self.pb = pb
1320
self.pb.note('starting upgrade from format 4 to 5')
1321
if isinstance(self.bzrdir.transport, LocalTransport):
1322
self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
1323
self._convert_to_weaves()
1324
return BzrDir.open(self.bzrdir.root_transport.base)
1325
1326
def _convert_to_weaves(self):
1327
self.pb.note('note: upgrade may be faster if all store files are ungzipped first')
1328
try:
1329
# TODO permissions
1330
stat = self.bzrdir.transport.stat('weaves')
1331
if not S_ISDIR(stat.st_mode):
1332
self.bzrdir.transport.delete('weaves')
1333
self.bzrdir.transport.mkdir('weaves')
1334
except errors.NoSuchFile:
1335
self.bzrdir.transport.mkdir('weaves')
1336
# deliberately not a WeaveFile as we want to build it up slowly.
1337
self.inv_weave = Weave('inventory')
1338
# holds in-memory weaves for all files
1339
self.text_weaves = {}
1340
self.bzrdir.transport.delete('branch-format')
1341
self.branch = self.bzrdir.open_branch()
1342
self._convert_working_inv()
1343
rev_history = self.branch.revision_history()
1344
# to_read is a stack holding the revisions we still need to process;
1345
# appending to it adds new highest-priority revisions
1346
self.known_revisions = set(rev_history)
1347
self.to_read = rev_history[-1:]
1348
while self.to_read:
1349
rev_id = self.to_read.pop()
1350
if (rev_id not in self.revisions
1351
and rev_id not in self.absent_revisions):
1352
self._load_one_rev(rev_id)
1353
self.pb.clear()
1354
to_import = self._make_order()
1355
for i, rev_id in enumerate(to_import):
1356
self.pb.update('converting revision', i, len(to_import))
1357
self._convert_one_rev(rev_id)
1358
self.pb.clear()
1359
self._write_all_weaves()
1360
self._write_all_revs()
1361
self.pb.note('upgraded to weaves:')
1362
self.pb.note(' %6d revisions and inventories', len(self.revisions))
1363
self.pb.note(' %6d revisions not present', len(self.absent_revisions))
1364
self.pb.note(' %6d texts', self.text_count)
1365
self._cleanup_spare_files_after_format4()
1366
self.branch.control_files.put_utf8('branch-format', BzrDirFormat5().get_format_string())
1367
1368
def _cleanup_spare_files_after_format4(self):
1369
# FIXME working tree upgrade foo.
1370
for n in 'merged-patches', 'pending-merged-patches':
1371
try:
1372
## assert os.path.getsize(p) == 0
1373
self.bzrdir.transport.delete(n)
1374
except errors.NoSuchFile:
1375
pass
1376
self.bzrdir.transport.delete_tree('inventory-store')
1377
self.bzrdir.transport.delete_tree('text-store')
1378
1379
def _convert_working_inv(self):
1380
inv = serializer_v4.read_inventory(self.branch.control_files.get('inventory'))
1381
new_inv_xml = serializer_v5.write_inventory_to_string(inv)
1382
# FIXME inventory is a working tree change.
1383
self.branch.control_files.put('inventory', new_inv_xml)
1384
1385
def _write_all_weaves(self):
1386
controlweaves = WeaveStore(self.bzrdir.transport, prefixed=False)
1387
weave_transport = self.bzrdir.transport.clone('weaves')
1388
weaves = WeaveStore(weave_transport, prefixed=False)
1389
transaction = WriteTransaction()
1390
1391
try:
1392
i = 0
1393
for file_id, file_weave in self.text_weaves.items():
1394
self.pb.update('writing weave', i, len(self.text_weaves))
1395
weaves._put_weave(file_id, file_weave, transaction)
1396
i += 1
1397
self.pb.update('inventory', 0, 1)
1398
controlweaves._put_weave('inventory', self.inv_weave, transaction)
1399
self.pb.update('inventory', 1, 1)
1400
finally:
1401
self.pb.clear()
1402
1403
def _write_all_revs(self):
1404
"""Write all revisions out in new form."""
1405
self.bzrdir.transport.delete_tree('revision-store')
1406
self.bzrdir.transport.mkdir('revision-store')
1407
revision_transport = self.bzrdir.transport.clone('revision-store')
1408
# TODO permissions
1409
_revision_store = TextRevisionStore(TextStore(revision_transport,
1410
prefixed=False,
1411
compressed=True))
1412
try:
1413
transaction = bzrlib.transactions.WriteTransaction()
1414
for i, rev_id in enumerate(self.converted_revs):
1415
self.pb.update('write revision', i, len(self.converted_revs))
1416
_revision_store.add_revision(self.revisions[rev_id], transaction)
1417
finally:
1418
self.pb.clear()
1419
1420
def _load_one_rev(self, rev_id):
1421
"""Load a revision object into memory.
1422
1423
Any parents not either loaded or abandoned get queued to be
1424
loaded."""
1425
self.pb.update('loading revision',
1426
len(self.revisions),
1427
len(self.known_revisions))
1428
if not self.branch.repository.has_revision(rev_id):
1429
self.pb.clear()
1430
self.pb.note('revision {%s} not present in branch; '
1431
'will be converted as a ghost',
1432
rev_id)
1433
self.absent_revisions.add(rev_id)
1434
else:
1435
rev = self.branch.repository._revision_store.get_revision(rev_id,
1436
self.branch.repository.get_transaction())
1437
for parent_id in rev.parent_ids:
1438
self.known_revisions.add(parent_id)
1439
self.to_read.append(parent_id)
1440
self.revisions[rev_id] = rev
1441
1442
def _load_old_inventory(self, rev_id):
1443
assert rev_id not in self.converted_revs
1444
old_inv_xml = self.branch.repository.inventory_store.get(rev_id).read()
1445
inv = serializer_v4.read_inventory_from_string(old_inv_xml)
1446
rev = self.revisions[rev_id]
1447
if rev.inventory_sha1:
1448
assert rev.inventory_sha1 == sha_string(old_inv_xml), \
1449
'inventory sha mismatch for {%s}' % rev_id
1450
return inv
1451
1452
def _load_updated_inventory(self, rev_id):
1453
assert rev_id in self.converted_revs
1454
inv_xml = self.inv_weave.get_text(rev_id)
1455
inv = serializer_v5.read_inventory_from_string(inv_xml)
1456
return inv
1457
1458
def _convert_one_rev(self, rev_id):
1459
"""Convert revision and all referenced objects to new format."""
1460
rev = self.revisions[rev_id]
1461
inv = self._load_old_inventory(rev_id)
1462
present_parents = [p for p in rev.parent_ids
1463
if p not in self.absent_revisions]
1464
self._convert_revision_contents(rev, inv, present_parents)
1465
self._store_new_weave(rev, inv, present_parents)
1466
self.converted_revs.add(rev_id)
1467
1468
def _store_new_weave(self, rev, inv, present_parents):
1469
# the XML is now updated with text versions
1470
if __debug__:
1471
for file_id in inv:
1472
ie = inv[file_id]
1473
if ie.kind == 'root_directory':
1474
continue
1475
assert hasattr(ie, 'revision'), \
1476
'no revision on {%s} in {%s}' % \
1477
(file_id, rev.revision_id)
1478
new_inv_xml = serializer_v5.write_inventory_to_string(inv)
1479
new_inv_sha1 = sha_string(new_inv_xml)
1480
self.inv_weave.add_lines(rev.revision_id,
1481
present_parents,
1482
new_inv_xml.splitlines(True))
1483
rev.inventory_sha1 = new_inv_sha1
1484
1485
def _convert_revision_contents(self, rev, inv, present_parents):
1486
"""Convert all the files within a revision.
1487
1488
Also upgrade the inventory to refer to the text revision ids."""
1489
rev_id = rev.revision_id
1490
mutter('converting texts of revision {%s}',
1491
rev_id)
1492
parent_invs = map(self._load_updated_inventory, present_parents)
1493
for file_id in inv:
1494
ie = inv[file_id]
1495
self._convert_file_version(rev, ie, parent_invs)
1496
1497
def _convert_file_version(self, rev, ie, parent_invs):
1498
"""Convert one version of one file.
1499
1500
The file needs to be added into the weave if it is a merge
1501
of >=2 parents or if it's changed from its parent.
1502
"""
1503
if ie.kind == 'root_directory':
1504
return
1505
file_id = ie.file_id
1506
rev_id = rev.revision_id
1507
w = self.text_weaves.get(file_id)
1508
if w is None:
1509
w = Weave(file_id)
1510
self.text_weaves[file_id] = w
1511
text_changed = False
1512
previous_entries = ie.find_previous_heads(parent_invs,
1513
None,
1514
None,
1515
entry_vf=w)
1516
for old_revision in previous_entries:
1517
# if this fails, its a ghost ?
1518
assert old_revision in self.converted_revs
1519
self.snapshot_ie(previous_entries, ie, w, rev_id)
1520
del ie.text_id
1521
assert getattr(ie, 'revision', None) is not None
1522
1523
def snapshot_ie(self, previous_revisions, ie, w, rev_id):
1524
# TODO: convert this logic, which is ~= snapshot to
1525
# a call to:. This needs the path figured out. rather than a work_tree
1526
# a v4 revision_tree can be given, or something that looks enough like
1527
# one to give the file content to the entry if it needs it.
1528
# and we need something that looks like a weave store for snapshot to
1529
# save against.
1530
#ie.snapshot(rev, PATH, previous_revisions, REVISION_TREE, InMemoryWeaveStore(self.text_weaves))
1531
if len(previous_revisions) == 1:
1532
previous_ie = previous_revisions.values()[0]
1533
if ie._unchanged(previous_ie):
1534
ie.revision = previous_ie.revision
1535
return
1536
if ie.has_text():
1537
text = self.branch.repository.text_store.get(ie.text_id)
1538
file_lines = text.readlines()
1539
assert sha_strings(file_lines) == ie.text_sha1
1540
assert sum(map(len, file_lines)) == ie.text_size
1541
w.add_lines(rev_id, previous_revisions, file_lines)
1542
self.text_count += 1
1543
else:
1544
w.add_lines(rev_id, previous_revisions, [])
1545
ie.revision = rev_id
1546
1547
def _make_order(self):
1548
"""Return a suitable order for importing revisions.
1549
1550
The order must be such that an revision is imported after all
1551
its (present) parents.
1552
"""
1553
todo = set(self.revisions.keys())
1554
done = self.absent_revisions.copy()
1555
order = []
1556
while todo:
1557
# scan through looking for a revision whose parents
1558
# are all done
1559
for rev_id in sorted(list(todo)):
1560
rev = self.revisions[rev_id]
1561
parent_ids = set(rev.parent_ids)
1562
if parent_ids.issubset(done):
1563
# can take this one now
1564
order.append(rev_id)
1565
todo.remove(rev_id)
1566
done.add(rev_id)
1567
return order
1568
1569
1570
class ConvertBzrDir5To6(Converter):
1571
"""Converts format 5 bzr dirs to format 6."""
1572
1573
def convert(self, to_convert, pb):
1574
"""See Converter.convert()."""
1575
self.bzrdir = to_convert
1576
self.pb = pb
1577
self.pb.note('starting upgrade from format 5 to 6')
1578
self._convert_to_prefixed()
1579
return BzrDir.open(self.bzrdir.root_transport.base)
1580
1581
def _convert_to_prefixed(self):
1582
from bzrlib.store import TransportStore
1583
self.bzrdir.transport.delete('branch-format')
1584
for store_name in ["weaves", "revision-store"]:
1585
self.pb.note("adding prefixes to %s" % store_name)
1586
store_transport = self.bzrdir.transport.clone(store_name)
1587
store = TransportStore(store_transport, prefixed=True)
1588
for urlfilename in store_transport.list_dir('.'):
1589
filename = urlunescape(urlfilename)
1590
if (filename.endswith(".weave") or
1591
filename.endswith(".gz") or
1592
filename.endswith(".sig")):
1593
file_id = os.path.splitext(filename)[0]
1594
else:
1595
file_id = filename
1596
prefix_dir = store.hash_prefix(file_id)
1597
# FIXME keep track of the dirs made RBC 20060121
1598
try:
1599
store_transport.move(filename, prefix_dir + '/' + filename)
1600
except errors.NoSuchFile: # catches missing dirs strangely enough
1601
store_transport.mkdir(prefix_dir)
1602
store_transport.move(filename, prefix_dir + '/' + filename)
1603
self.bzrdir._control_files.put_utf8('branch-format', BzrDirFormat6().get_format_string())
1604
1605
1606
class ConvertBzrDir6ToMeta(Converter):
1607
"""Converts format 6 bzr dirs to metadirs."""
1608
1609
def convert(self, to_convert, pb):
1610
"""See Converter.convert()."""
1611
self.bzrdir = to_convert
1612
self.pb = pb
1613
self.count = 0
1614
self.total = 20 # the steps we know about
1615
self.garbage_inventories = []
1616
1617
self.pb.note('starting upgrade from format 6 to metadir')
1618
self.bzrdir._control_files.put_utf8('branch-format', "Converting to format 6")
1619
# its faster to move specific files around than to open and use the apis...
1620
# first off, nuke ancestry.weave, it was never used.
1621
try:
1622
self.step('Removing ancestry.weave')
1623
self.bzrdir.transport.delete('ancestry.weave')
1624
except errors.NoSuchFile:
1625
pass
1626
# find out whats there
1627
self.step('Finding branch files')
1628
last_revision = self.bzrdir.open_workingtree().last_revision()
1629
bzrcontents = self.bzrdir.transport.list_dir('.')
1630
for name in bzrcontents:
1631
if name.startswith('basis-inventory.'):
1632
self.garbage_inventories.append(name)
1633
# create new directories for repository, working tree and branch
1634
self.dir_mode = self.bzrdir._control_files._dir_mode
1635
self.file_mode = self.bzrdir._control_files._file_mode
1636
repository_names = [('inventory.weave', True),
1637
('revision-store', True),
1638
('weaves', True)]
1639
self.step('Upgrading repository ')
1640
self.bzrdir.transport.mkdir('repository', mode=self.dir_mode)
1641
self.make_lock('repository')
1642
# we hard code the formats here because we are converting into
1643
# the meta format. The meta format upgrader can take this to a
1644
# future format within each component.
1645
self.put_format('repository', bzrlib.repository.RepositoryFormat7())
1646
for entry in repository_names:
1647
self.move_entry('repository', entry)
1648
1649
self.step('Upgrading branch ')
1650
self.bzrdir.transport.mkdir('branch', mode=self.dir_mode)
1651
self.make_lock('branch')
1652
self.put_format('branch', bzrlib.branch.BzrBranchFormat5())
1653
branch_files = [('revision-history', True),
1654
('branch-name', True),
1655
('parent', False)]
1656
for entry in branch_files:
1657
self.move_entry('branch', entry)
1658
1659
self.step('Upgrading working tree')
1660
self.bzrdir.transport.mkdir('checkout', mode=self.dir_mode)
1661
self.make_lock('checkout')
1662
self.put_format('checkout', bzrlib.workingtree.WorkingTreeFormat3())
1663
self.bzrdir.transport.delete_multi(self.garbage_inventories, self.pb)
1664
checkout_files = [('pending-merges', True),
1665
('inventory', True),
1666
('stat-cache', False)]
1667
for entry in checkout_files:
1668
self.move_entry('checkout', entry)
1669
if last_revision is not None:
1670
self.bzrdir._control_files.put_utf8('checkout/last-revision',
1671
last_revision)
1672
self.bzrdir._control_files.put_utf8('branch-format', BzrDirMetaFormat1().get_format_string())
1673
return BzrDir.open(self.bzrdir.root_transport.base)
1674
1675
def make_lock(self, name):
1676
"""Make a lock for the new control dir name."""
1677
self.step('Make %s lock' % name)
1678
ld = LockDir(self.bzrdir.transport,
1679
'%s/lock' % name,
1680
file_modebits=self.file_mode,
1681
dir_modebits=self.dir_mode)
1682
ld.create()
1683
1684
def move_entry(self, new_dir, entry):
1685
"""Move then entry name into new_dir."""
1686
name = entry[0]
1687
mandatory = entry[1]
1688
self.step('Moving %s' % name)
1689
try:
1690
self.bzrdir.transport.move(name, '%s/%s' % (new_dir, name))
1691
except errors.NoSuchFile:
1692
if mandatory:
1693
raise
1694
1695
def put_format(self, dirname, format):
1696
self.bzrdir._control_files.put_utf8('%s/format' % dirname, format.get_format_string())
1697
1698
1699
class ConvertMetaToMeta(Converter):
1700
"""Converts the components of metadirs."""
1701
1702
def __init__(self, target_format):
1703
"""Create a metadir to metadir converter.
1704
1705
:param target_format: The final metadir format that is desired.
1706
"""
1707
self.target_format = target_format
1708
1709
def convert(self, to_convert, pb):
1710
"""See Converter.convert()."""
1711
self.bzrdir = to_convert
1712
self.pb = pb
1713
self.count = 0
1714
self.total = 1
1715
self.step('checking repository format')
1716
try:
1717
repo = self.bzrdir.open_repository()
1718
except errors.NoRepositoryPresent:
1719
pass
1720
else:
1721
if not isinstance(repo._format, self.target_format.repository_format.__class__):
1722
from bzrlib.repository import CopyConverter
1723
self.pb.note('starting repository conversion')
1724
converter = CopyConverter(self.target_format.repository_format)
1725
converter.convert(repo, pb)
1726
return to_convert
Loggerhead is a web-based interface for Breezy
Version: 2.0.1