/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: Martin Pool
  • Date: 2006-05-04 06:07:43 UTC
  • mto: This revision was merged to the branch mainline in revision 1699.
  • Revision ID: mbp@sourcefrog.net-20060504060743-cdcb40c14eb62d10
When a diff prefix is given, don't show it in === summary lines, only on the diffs themselves.

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