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