/brz/remove-bazaar

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

(test_escaped_store) fix typo

Show diffs side-by-side

added added

removed removed

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