/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

  • Committer: John Arbash Meinel
  • Date: 2006-04-27 15:14:36 UTC
  • mto: This revision was merged to the branch mainline in revision 1752.
  • Revision ID: john@arbash-meinel.com-20060427151436-eb8c2328f7ea15f3
Repository had a bug with what exception was raised when a file was missing

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