/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

Introduce new bzr progress bar api. ui_factory.nested_progress_bar.

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