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