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