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