← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bzrdir.py

  • Committer: John Arbash Meinel
  • Date: 2006-10-24 14:12:53 UTC
  • mto: This revision was merged to the branch mainline in revision 2095.
  • Revision ID: john@arbash-meinel.com-20061024141253-783fba812b197b70
(John Arbash Meinel) Update version information for 0.13 development

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bzrdir.py
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
20
20
directories.
21
21
"""
22
22
 
 
23
# TODO: remove unittest dependency; put that stuff inside the test suite
 
24
 
 
25
# TODO: The Format probe_transport seems a bit redundant with just trying to
 
26
# open the bzrdir. -- mbp
 
27
#
23
28
# TODO: Can we move specific formats into separate modules to make this file
24
29
# smaller?
25
30
 
26
31
from cStringIO import StringIO
27
32
import os
28
 
import textwrap
29
33
 
30
34
from bzrlib.lazy_import import lazy_import
31
35
lazy_import(globals(), """
 
36
from copy import deepcopy
32
37
from stat import S_ISDIR
 
38
import unittest
33
39
 
34
40
import bzrlib
35
41
from bzrlib import (
36
42
    errors,
37
43
    lockable_files,
38
44
    lockdir,
39
 
    registry,
40
 
    remote,
41
45
    revision as _mod_revision,
42
 
    symbol_versioning,
43
 
    ui,
44
46
    urlutils,
45
47
    xml4,
46
48
    xml5,
47
 
    workingtree,
48
 
    workingtree_4,
49
49
    )
50
50
from bzrlib.osutils import (
 
51
    safe_unicode,
51
52
    sha_strings,
52
53
    sha_string,
53
54
    )
54
 
from bzrlib.smart.client import _SmartClient
55
 
from bzrlib.smart import protocol
56
55
from bzrlib.store.revision.text import TextRevisionStore
57
56
from bzrlib.store.text import TextStore
58
57
from bzrlib.store.versioned import WeaveStore
59
58
from bzrlib.transactions import WriteTransaction
60
 
from bzrlib.transport import (
61
 
    do_catching_redirections,
62
 
    get_transport,
63
 
    )
 
59
from bzrlib.transport import get_transport
64
60
from bzrlib.weave import Weave
65
61
""")
66
62
 
67
 
from bzrlib.trace import (
68
 
    mutter,
69
 
    note,
70
 
    )
 
63
from bzrlib.trace import mutter
71
64
from bzrlib.transport.local import LocalTransport
72
65
 
73
66
 
89
82
        If there is a tree, the tree is opened and break_lock() called.
90
83
        Otherwise, branch is tried, and finally repository.
91
84
        """
92
 
        # XXX: This seems more like a UI function than something that really
93
 
        # belongs in this class.
94
85
        try:
95
86
            thing_to_unlock = self.open_workingtree()
96
87
        except (errors.NotLocalUrl, errors.NoWorkingTree):
113
104
        source_repo_format.check_conversion_target(target_repo_format)
114
105
 
115
106
    @staticmethod
116
 
    def _check_supported(format, allow_unsupported,
117
 
        recommend_upgrade=True,
118
 
        basedir=None):
119
 
        """Give an error or warning on old formats.
120
 
 
121
 
        :param format: may be any kind of format - workingtree, branch, 
122
 
        or repository.
123
 
 
124
 
        :param allow_unsupported: If true, allow opening 
125
 
        formats that are strongly deprecated, and which may 
126
 
        have limited functionality.
127
 
 
128
 
        :param recommend_upgrade: If true (default), warn
129
 
        the user through the ui object that they may wish
130
 
        to upgrade the object.
 
107
    def _check_supported(format, allow_unsupported):
 
108
        """Check whether format is a supported format.
 
109
 
 
110
        If allow_unsupported is True, this is a no-op.
131
111
        """
132
 
        # TODO: perhaps move this into a base Format class; it's not BzrDir
133
 
        # specific. mbp 20070323
134
112
        if not allow_unsupported and not format.is_supported():
135
113
            # see open_downlevel to open legacy branches.
136
114
            raise errors.UnsupportedFormatError(format=format)
137
 
        if recommend_upgrade \
138
 
            and getattr(format, 'upgrade_recommended', False):
139
 
            ui.ui_factory.recommend_upgrade(
140
 
                format.get_format_description(),
141
 
                basedir)
142
115
 
143
 
    def clone(self, url, revision_id=None, force_new_repo=False):
 
116
    def clone(self, url, revision_id=None, basis=None, force_new_repo=False):
144
117
        """Clone this bzrdir and its contents to url verbatim.
145
118
 
146
119
        If urls last component does not exist, it will be created.
150
123
        :param force_new_repo: Do not use a shared repository for the target 
151
124
                               even if one is available.
152
125
        """
153
 
        return self.clone_on_transport(get_transport(url),
154
 
                                       revision_id=revision_id,
155
 
                                       force_new_repo=force_new_repo)
156
 
 
157
 
    def clone_on_transport(self, transport, revision_id=None,
158
 
                           force_new_repo=False):
159
 
        """Clone this bzrdir and its contents to transport verbatim.
160
 
 
161
 
        If the target directory does not exist, it will be created.
162
 
 
163
 
        if revision_id is not None, then the clone operation may tune
164
 
            itself to download less data.
165
 
        :param force_new_repo: Do not use a shared repository for the target 
166
 
                               even if one is available.
167
 
        """
168
 
        transport.ensure_base()
169
 
        result = self._format.initialize_on_transport(transport)
 
126
        self._make_tail(url)
 
127
        basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
 
128
        result = self._format.initialize(url)
170
129
        try:
171
130
            local_repo = self.find_repository()
172
131
        except errors.NoRepositoryPresent:
176
135
            if force_new_repo:
177
136
                result_repo = local_repo.clone(
178
137
                    result,
179
 
                    revision_id=revision_id)
 
138
                    revision_id=revision_id,
 
139
                    basis=basis_repo)
180
140
                result_repo.set_make_working_trees(local_repo.make_working_trees())
181
141
            else:
182
142
                try:
183
143
                    result_repo = result.find_repository()
184
144
                    # fetch content this dir needs.
 
145
                    if basis_repo:
 
146
                        # XXX FIXME RBC 20060214 need tests for this when the basis
 
147
                        # is incomplete
 
148
                        result_repo.fetch(basis_repo, revision_id=revision_id)
185
149
                    result_repo.fetch(local_repo, revision_id=revision_id)
186
150
                except errors.NoRepositoryPresent:
187
151
                    # needed to make one anyway.
188
152
                    result_repo = local_repo.clone(
189
153
                        result,
190
 
                        revision_id=revision_id)
 
154
                        revision_id=revision_id,
 
155
                        basis=basis_repo)
191
156
                    result_repo.set_make_working_trees(local_repo.make_working_trees())
192
157
        # 1 if there is a branch present
193
158
        #   make sure its content is available in the target repository
197
162
        except errors.NotBranchError:
198
163
            pass
199
164
        try:
200
 
            self.open_workingtree().clone(result)
 
165
            self.open_workingtree().clone(result, basis=basis_tree)
201
166
        except (errors.NoWorkingTree, errors.NotLocalUrl):
202
167
            pass
203
168
        return result
204
169
 
 
170
    def _get_basis_components(self, basis):
 
171
        """Retrieve the basis components that are available at basis."""
 
172
        if basis is None:
 
173
            return None, None, None
 
174
        try:
 
175
            basis_tree = basis.open_workingtree()
 
176
            basis_branch = basis_tree.branch
 
177
            basis_repo = basis_branch.repository
 
178
        except (errors.NoWorkingTree, errors.NotLocalUrl):
 
179
            basis_tree = None
 
180
            try:
 
181
                basis_branch = basis.open_branch()
 
182
                basis_repo = basis_branch.repository
 
183
            except errors.NotBranchError:
 
184
                basis_branch = None
 
185
                try:
 
186
                    basis_repo = basis.open_repository()
 
187
                except errors.NoRepositoryPresent:
 
188
                    basis_repo = None
 
189
        return basis_repo, basis_branch, basis_tree
 
190
 
205
191
    # TODO: This should be given a Transport, and should chdir up; otherwise
206
192
    # this will open a new connection.
207
193
    def _make_tail(self, url):
208
 
        t = get_transport(url)
209
 
        t.ensure_base()
 
194
        head, tail = urlutils.split(url)
 
195
        if tail and tail != '.':
 
196
            t = get_transport(head)
 
197
            try:
 
198
                t.mkdir(tail)
 
199
            except errors.FileExists:
 
200
                pass
210
201
 
 
202
    # TODO: Should take a Transport
211
203
    @classmethod
212
 
    def create(cls, base, format=None, possible_transports=None):
 
204
    def create(cls, base):
213
205
        """Create a new BzrDir at the url 'base'.
214
206
        
215
207
        This will call the current default formats initialize with base
216
208
        as the only parameter.
217
209
 
218
 
        :param format: If supplied, the format of branch to create.  If not
219
 
            supplied, the default is used.
220
 
        :param possible_transports: If supplied, a list of transports that 
221
 
            can be reused to share a remote connection.
 
210
        If you need a specific format, consider creating an instance
 
211
        of that and calling initialize().
222
212
        """
223
213
        if cls is not BzrDir:
224
 
            raise AssertionError("BzrDir.create always creates the default"
225
 
                " format, not one of %r" % cls)
226
 
        t = get_transport(base, possible_transports)
227
 
        t.ensure_base()
228
 
        if format is None:
229
 
            format = BzrDirFormat.get_default_format()
230
 
        return format.initialize(base, possible_transports)
 
214
            raise AssertionError("BzrDir.create always creates the default format, "
 
215
                    "not one of %r" % cls)
 
216
        head, tail = urlutils.split(base)
 
217
        if tail and tail != '.':
 
218
            t = get_transport(head)
 
219
            try:
 
220
                t.mkdir(tail)
 
221
            except errors.FileExists:
 
222
                pass
 
223
        return BzrDirFormat.get_default_format().initialize(safe_unicode(base))
231
224
 
232
225
    def create_branch(self):
233
226
        """Create a branch in this BzrDir.
238
231
        raise NotImplementedError(self.create_branch)
239
232
 
240
233
    @staticmethod
241
 
    def create_branch_and_repo(base, force_new_repo=False, format=None):
 
234
    def create_branch_and_repo(base, force_new_repo=False):
242
235
        """Create a new BzrDir, Branch and Repository at the url 'base'.
243
236
 
244
237
        This will use the current default BzrDirFormat, and use whatever 
251
244
        :param base: The URL to create the branch at.
252
245
        :param force_new_repo: If True a new repository is always created.
253
246
        """
254
 
        bzrdir = BzrDir.create(base, format)
 
247
        bzrdir = BzrDir.create(base)
255
248
        bzrdir._find_or_create_repository(force_new_repo)
256
249
        return bzrdir.create_branch()
257
250
 
266
259
        
267
260
    @staticmethod
268
261
    def create_branch_convenience(base, force_new_repo=False,
269
 
                                  force_new_tree=None, format=None,
270
 
                                  possible_transports=None):
 
262
                                  force_new_tree=None, format=None):
271
263
        """Create a new BzrDir, Branch and Repository at the url 'base'.
272
264
 
273
265
        This is a convenience function - it will use an existing repository
289
281
        :param force_new_repo: If True a new repository is always created.
290
282
        :param force_new_tree: If True or False force creation of a tree or 
291
283
                               prevent such creation respectively.
292
 
        :param format: Override for the for the bzrdir format to create.
293
 
        :param possible_transports: An optional reusable transports list.
 
284
        :param format: Override for the for the bzrdir format to create
294
285
        """
295
286
        if force_new_tree:
296
287
            # check for non local urls
297
 
            t = get_transport(base, possible_transports)
 
288
            t = get_transport(safe_unicode(base))
298
289
            if not isinstance(t, LocalTransport):
299
290
                raise errors.NotLocalUrl(base)
300
 
        bzrdir = BzrDir.create(base, format, possible_transports)
 
291
        if format is None:
 
292
            bzrdir = BzrDir.create(base)
 
293
        else:
 
294
            bzrdir = format.initialize(base)
301
295
        repo = bzrdir._find_or_create_repository(force_new_repo)
302
296
        result = bzrdir.create_branch()
303
 
        if force_new_tree or (repo.make_working_trees() and
 
297
        if force_new_tree or (repo.make_working_trees() and 
304
298
                              force_new_tree is None):
305
299
            try:
306
300
                bzrdir.create_workingtree()
307
301
            except errors.NotLocalUrl:
308
302
                pass
309
303
        return result
310
 
 
 
304
        
311
305
    @staticmethod
312
 
    def create_repository(base, shared=False, format=None):
 
306
    def create_repository(base, shared=False):
313
307
        """Create a new BzrDir and Repository at the url 'base'.
314
308
 
315
 
        If no format is supplied, this will default to the current default
316
 
        BzrDirFormat by default, and use whatever repository format that that
317
 
        uses for bzrdirformat.create_repository.
 
309
        This will use the current default BzrDirFormat, and use whatever 
 
310
        repository format that that uses for bzrdirformat.create_repository.
318
311
 
319
312
        :param shared: Create a shared repository rather than a standalone
320
313
                       repository.
324
317
        it should take no parameters and construct whatever repository format
325
318
        that child class desires.
326
319
        """
327
 
        bzrdir = BzrDir.create(base, format)
 
320
        bzrdir = BzrDir.create(base)
328
321
        return bzrdir.create_repository(shared)
329
322
 
330
323
    @staticmethod
331
 
    def create_standalone_workingtree(base, format=None):
 
324
    def create_standalone_workingtree(base):
332
325
        """Create a new BzrDir, WorkingTree, Branch and Repository at 'base'.
333
326
 
334
327
        'base' must be a local path or a file:// url.
339
332
 
340
333
        :return: The WorkingTree object.
341
334
        """
342
 
        t = get_transport(base)
 
335
        t = get_transport(safe_unicode(base))
343
336
        if not isinstance(t, LocalTransport):
344
337
            raise errors.NotLocalUrl(base)
345
 
        bzrdir = BzrDir.create_branch_and_repo(base,
346
 
                                               force_new_repo=True,
347
 
                                               format=format).bzrdir
 
338
        bzrdir = BzrDir.create_branch_and_repo(safe_unicode(base),
 
339
                                               force_new_repo=True).bzrdir
348
340
        return bzrdir.create_workingtree()
349
341
 
350
342
    def create_workingtree(self, revision_id=None):
354
346
        """
355
347
        raise NotImplementedError(self.create_workingtree)
356
348
 
357
 
    def retire_bzrdir(self):
358
 
        """Permanently disable the bzrdir.
359
 
 
360
 
        This is done by renaming it to give the user some ability to recover
361
 
        if there was a problem.
362
 
 
363
 
        This will have horrible consequences if anyone has anything locked or
364
 
        in use.
365
 
        """
366
 
        for i in xrange(10000):
367
 
            try:
368
 
                to_path = '.bzr.retired.%d' % i
369
 
                self.root_transport.rename('.bzr', to_path)
370
 
                note("renamed %s to %s"
371
 
                    % (self.root_transport.abspath('.bzr'), to_path))
372
 
                break
373
 
            except (errors.TransportError, IOError, errors.PathError):
374
 
                pass
375
 
 
376
349
    def destroy_workingtree(self):
377
350
        """Destroy the working tree at this BzrDir.
378
351
 
418
391
                    break
419
392
                else:
420
393
                    continue
421
 
            if ((found_bzrdir.root_transport.base ==
 
394
            if ((found_bzrdir.root_transport.base == 
422
395
                 self.root_transport.base) or repository.is_shared()):
423
396
                return repository
424
397
            else:
425
398
                raise errors.NoRepositoryPresent(self)
426
399
        raise errors.NoRepositoryPresent(self)
427
400
 
428
 
    def get_branch_reference(self):
429
 
        """Return the referenced URL for the branch in this bzrdir.
430
 
 
431
 
        :raises NotBranchError: If there is no Branch.
432
 
        :return: The URL the branch in this bzrdir references if it is a
433
 
            reference branch, or None for regular branches.
434
 
        """
435
 
        return None
436
 
 
437
401
    def get_branch_transport(self, branch_format):
438
402
        """Get the transport for use by branch format in this BzrDir.
439
403
 
464
428
        """Get the transport for use by workingtree format in this BzrDir.
465
429
 
466
430
        Note that bzr dirs that do not support format strings will raise
467
 
        IncompatibleFormat if the workingtree format they are given has a
468
 
        format string, and vice versa.
 
431
        IncompatibleFormat if the workingtree format they are given has
 
432
        a format string, and vice versa.
469
433
 
470
434
        If workingtree_format is None, the transport is returned with no 
471
435
        checking. if it is not None, then the returned transport is
531
495
        return BzrDir.open_from_transport(t, _unsupported=_unsupported)
532
496
 
533
497
    @staticmethod
534
 
    def open_from_transport(transport, _unsupported=False,
535
 
                            _server_formats=True):
 
498
    def open_from_transport(transport, _unsupported=False):
536
499
        """Open a bzrdir within a particular directory.
537
500
 
538
501
        :param transport: Transport containing the bzrdir.
539
502
        :param _unsupported: private.
540
503
        """
541
 
        base = transport.base
542
 
 
543
 
        def find_format(transport):
544
 
            return transport, BzrDirFormat.find_format(
545
 
                transport, _server_formats=_server_formats)
546
 
 
547
 
        def redirected(transport, e, redirection_notice):
548
 
            qualified_source = e.get_source_url()
549
 
            relpath = transport.relpath(qualified_source)
550
 
            if not e.target.endswith(relpath):
551
 
                # Not redirected to a branch-format, not a branch
552
 
                raise errors.NotBranchError(path=e.target)
553
 
            target = e.target[:-len(relpath)]
554
 
            note('%s is%s redirected to %s',
555
 
                 transport.base, e.permanently, target)
556
 
            # Let's try with a new transport
557
 
            qualified_target = e.get_target_url()[:-len(relpath)]
558
 
            # FIXME: If 'transport' has a qualifier, this should
559
 
            # be applied again to the new transport *iff* the
560
 
            # schemes used are the same. It's a bit tricky to
561
 
            # verify, so I'll punt for now
562
 
            # -- vila20070212
563
 
            return get_transport(target)
564
 
 
565
 
        try:
566
 
            transport, format = do_catching_redirections(find_format,
567
 
                                                         transport,
568
 
                                                         redirected)
569
 
        except errors.TooManyRedirections:
570
 
            raise errors.NotBranchError(base)
571
 
 
 
504
        format = BzrDirFormat.find_format(transport)
572
505
        BzrDir._check_supported(format, _unsupported)
573
506
        return format.open(transport, _found=True)
574
507
 
583
516
        raise NotImplementedError(self.open_branch)
584
517
 
585
518
    @staticmethod
586
 
    def open_containing(url, possible_transports=None):
 
519
    def open_containing(url):
587
520
        """Open an existing branch which contains url.
588
521
        
589
522
        :param url: url to search from.
590
523
        See open_containing_from_transport for more detail.
591
524
        """
592
 
        transport = get_transport(url, possible_transports)
593
 
        return BzrDir.open_containing_from_transport(transport)
 
525
        return BzrDir.open_containing_from_transport(get_transport(url))
594
526
    
595
527
    @staticmethod
596
528
    def open_containing_from_transport(a_transport):
615
547
                return result, urlutils.unescape(a_transport.relpath(url))
616
548
            except errors.NotBranchError, e:
617
549
                pass
618
 
            try:
619
 
                new_t = a_transport.clone('..')
620
 
            except errors.InvalidURLJoin:
621
 
                # reached the root, whatever that may be
622
 
                raise errors.NotBranchError(path=url)
 
550
            new_t = a_transport.clone('..')
623
551
            if new_t.base == a_transport.base:
624
552
                # reached the root, whatever that may be
625
553
                raise errors.NotBranchError(path=url)
626
554
            a_transport = new_t
627
555
 
628
 
    @classmethod
629
 
    def open_containing_tree_or_branch(klass, location):
630
 
        """Return the branch and working tree contained by a location.
631
 
 
632
 
        Returns (tree, branch, relpath).
633
 
        If there is no tree at containing the location, tree will be None.
634
 
        If there is no branch containing the location, an exception will be
635
 
        raised
636
 
        relpath is the portion of the path that is contained by the branch.
637
 
        """
638
 
        bzrdir, relpath = klass.open_containing(location)
639
 
        try:
640
 
            tree = bzrdir.open_workingtree()
641
 
        except (errors.NoWorkingTree, errors.NotLocalUrl):
642
 
            tree = None
643
 
            branch = bzrdir.open_branch()
644
 
        else:
645
 
            branch = tree.branch
646
 
        return tree, branch, relpath
647
 
 
648
556
    def open_repository(self, _unsupported=False):
649
557
        """Open the repository object at this BzrDir if one is present.
650
558
 
657
565
        """
658
566
        raise NotImplementedError(self.open_repository)
659
567
 
660
 
    def open_workingtree(self, _unsupported=False,
661
 
            recommend_upgrade=True):
 
568
    def open_workingtree(self, _unsupported=False):
662
569
        """Open the workingtree object at this BzrDir if one is present.
663
 
 
664
 
        :param recommend_upgrade: Optional keyword parameter, when True (the
665
 
            default), emit through the ui module a recommendation that the user
666
 
            upgrade the working tree when the workingtree being opened is old
667
 
            (but still fully supported).
 
570
        
 
571
        TODO: static convenience version of this?
668
572
        """
669
573
        raise NotImplementedError(self.open_workingtree)
670
574
 
692
596
        workingtree and discards it, and that's somewhat expensive.) 
693
597
        """
694
598
        try:
695
 
            self.open_workingtree(recommend_upgrade=False)
 
599
            self.open_workingtree()
696
600
            return True
697
601
        except errors.NoWorkingTree:
698
602
            return False
699
603
 
700
 
    def _cloning_metadir(self):
 
604
    def cloning_metadir(self, basis=None):
701
605
        """Produce a metadir suitable for cloning with"""
 
606
        def related_repository(bzrdir):
 
607
            try:
 
608
                branch = bzrdir.open_branch()
 
609
                return branch.repository
 
610
            except errors.NotBranchError:
 
611
                source_branch = None
 
612
                return bzrdir.open_repository()
702
613
        result_format = self._format.__class__()
703
614
        try:
704
615
            try:
705
 
                branch = self.open_branch()
706
 
                source_repository = branch.repository
707
 
            except errors.NotBranchError:
708
 
                source_branch = None
709
 
                source_repository = self.open_repository()
 
616
                source_repository = related_repository(self)
 
617
            except errors.NoRepositoryPresent:
 
618
                if basis is None:
 
619
                    raise
 
620
                source_repository = related_repository(self)
 
621
            result_format.repository_format = source_repository._format
710
622
        except errors.NoRepositoryPresent:
711
 
            source_repository = None
712
 
        else:
713
 
            # XXX TODO: This isinstance is here because we have not implemented
714
 
            # the fix recommended in bug # 103195 - to delegate this choice the
715
 
            # repository itself.
716
 
            repo_format = source_repository._format
717
 
            if not isinstance(repo_format, remote.RemoteRepositoryFormat):
718
 
                result_format.repository_format = repo_format
719
 
        try:
720
 
            # TODO: Couldn't we just probe for the format in these cases,
721
 
            # rather than opening the whole tree?  It would be a little
722
 
            # faster. mbp 20070401
723
 
            tree = self.open_workingtree(recommend_upgrade=False)
724
 
        except (errors.NoWorkingTree, errors.NotLocalUrl):
725
 
            result_format.workingtree_format = None
726
 
        else:
727
 
            result_format.workingtree_format = tree._format.__class__()
728
 
        return result_format, source_repository
729
 
 
730
 
    def cloning_metadir(self):
731
 
        """Produce a metadir suitable for cloning or sprouting with.
732
 
 
733
 
        These operations may produce workingtrees (yes, even though they're
734
 
        "cloning" something that doesn't have a tree, so a viable workingtree
735
 
        format must be selected.
736
 
        """
737
 
        format, repository = self._cloning_metadir()
738
 
        if format._workingtree_format is None:
739
 
            if repository is None:
740
 
                return format
741
 
            tree_format = repository._format._matchingbzrdir.workingtree_format
742
 
            format.workingtree_format = tree_format.__class__()
743
 
        return format
744
 
 
745
 
    def checkout_metadir(self):
746
 
        return self.cloning_metadir()
747
 
 
748
 
    def sprout(self, url, revision_id=None, force_new_repo=False,
749
 
               recurse='down', possible_transports=None):
 
623
            pass
 
624
        return result_format
 
625
 
 
626
    def sprout(self, url, revision_id=None, basis=None, force_new_repo=False):
750
627
        """Create a copy of this bzrdir prepared for use as a new line of
751
628
        development.
752
629
 
760
637
        if revision_id is not None, then the clone operation may tune
761
638
            itself to download less data.
762
639
        """
763
 
        target_transport = get_transport(url, possible_transports)
764
 
        target_transport.ensure_base()
765
 
        cloning_format = self.cloning_metadir()
766
 
        result = cloning_format.initialize_on_transport(target_transport)
 
640
        self._make_tail(url)
 
641
        cloning_format = self.cloning_metadir(basis)
 
642
        result = cloning_format.initialize(url)
 
643
        basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
767
644
        try:
768
645
            source_branch = self.open_branch()
769
646
            source_repository = source_branch.repository
772
649
            try:
773
650
                source_repository = self.open_repository()
774
651
            except errors.NoRepositoryPresent:
775
 
                source_repository = None
 
652
                # copy the entire basis one if there is one
 
653
                # but there is no repository.
 
654
                source_repository = basis_repo
776
655
        if force_new_repo:
777
656
            result_repo = None
778
657
        else:
787
666
            result.create_repository()
788
667
        elif source_repository is not None and result_repo is None:
789
668
            # have source, and want to make a new target repo
790
 
            result_repo = source_repository.sprout(result,
791
 
                                                   revision_id=revision_id)
792
 
        else:
 
669
            # we don't clone the repo because that preserves attributes
 
670
            # like is_shared(), and we have not yet implemented a 
 
671
            # repository sprout().
 
672
            result_repo = result.create_repository()
 
673
        if result_repo is not None:
793
674
            # fetch needed content into target.
 
675
            if basis_repo:
 
676
                # XXX FIXME RBC 20060214 need tests for this when the basis
 
677
                # is incomplete
 
678
                result_repo.fetch(basis_repo, revision_id=revision_id)
794
679
            if source_repository is not None:
795
 
                # would rather do 
796
 
                # source_repository.copy_content_into(result_repo,
797
 
                #                                     revision_id=revision_id)
798
 
                # so we can override the copy method
799
680
                result_repo.fetch(source_repository, revision_id=revision_id)
800
681
        if source_branch is not None:
801
682
            source_branch.sprout(result, revision_id=revision_id)
802
683
        else:
803
684
            result.create_branch()
804
 
        if isinstance(target_transport, LocalTransport) and (
805
 
            result_repo is None or result_repo.make_working_trees()):
 
685
        # TODO: jam 20060426 we probably need a test in here in the
 
686
        #       case that the newly sprouted branch is a remote one
 
687
        if result_repo is None or result_repo.make_working_trees():
806
688
            wt = result.create_workingtree()
807
 
            wt.lock_write()
808
 
            try:
809
 
                if wt.path2id('') is None:
810
 
                    try:
811
 
                        wt.set_root_id(self.open_workingtree.get_root_id())
812
 
                    except errors.NoWorkingTree:
813
 
                        pass
814
 
            finally:
815
 
                wt.unlock()
816
 
        else:
817
 
            wt = None
818
 
        if recurse == 'down':
819
 
            if wt is not None:
820
 
                basis = wt.basis_tree()
821
 
                basis.lock_read()
822
 
                subtrees = basis.iter_references()
823
 
                recurse_branch = wt.branch
824
 
            elif source_branch is not None:
825
 
                basis = source_branch.basis_tree()
826
 
                basis.lock_read()
827
 
                subtrees = basis.iter_references()
828
 
                recurse_branch = source_branch
829
 
            else:
830
 
                subtrees = []
831
 
                basis = None
832
 
            try:
833
 
                for path, file_id in subtrees:
834
 
                    target = urlutils.join(url, urlutils.escape(path))
835
 
                    sublocation = source_branch.reference_parent(file_id, path)
836
 
                    sublocation.bzrdir.sprout(target,
837
 
                        basis.get_reference_revision(file_id, path),
838
 
                        force_new_repo=force_new_repo, recurse=recurse)
839
 
            finally:
840
 
                if basis is not None:
841
 
                    basis.unlock()
 
689
            if wt.inventory.root is None:
 
690
                try:
 
691
                    wt.set_root_id(self.open_workingtree.get_root_id())
 
692
                except errors.NoWorkingTree:
 
693
                    pass
842
694
        return result
843
695
 
844
696
 
859
711
        """Pre-splitout bzrdirs do not suffer from stale locks."""
860
712
        raise NotImplementedError(self.break_lock)
861
713
 
862
 
    def clone(self, url, revision_id=None, force_new_repo=False):
 
714
    def clone(self, url, revision_id=None, basis=None, force_new_repo=False):
863
715
        """See BzrDir.clone()."""
864
716
        from bzrlib.workingtree import WorkingTreeFormat2
865
717
        self._make_tail(url)
866
718
        result = self._format._initialize_for_clone(url)
867
 
        self.open_repository().clone(result, revision_id=revision_id)
 
719
        basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
 
720
        self.open_repository().clone(result, revision_id=revision_id, basis=basis_repo)
868
721
        from_branch = self.open_branch()
869
722
        from_branch.clone(result, revision_id=revision_id)
870
723
        try:
871
 
            self.open_workingtree().clone(result)
 
724
            self.open_workingtree().clone(result, basis=basis_tree)
872
725
        except errors.NotLocalUrl:
873
726
            # make a new one, this format always has to have one.
874
727
            try:
892
745
    def create_workingtree(self, revision_id=None):
893
746
        """See BzrDir.create_workingtree."""
894
747
        # this looks buggy but is not -really-
895
 
        # because this format creates the workingtree when the bzrdir is
896
 
        # created
897
748
        # clone and sprout will have set the revision_id
898
749
        # and that will have set it for us, its only
899
750
        # specific uses of create_workingtree in isolation
900
751
        # that can do wonky stuff here, and that only
901
752
        # happens for creating checkouts, which cannot be 
902
753
        # done on this format anyway. So - acceptable wart.
903
 
        result = self.open_workingtree(recommend_upgrade=False)
 
754
        result = self.open_workingtree()
904
755
        if revision_id is not None:
905
756
            if revision_id == _mod_revision.NULL_REVISION:
906
757
                result.set_parent_ids([])
962
813
        self._check_supported(format, unsupported)
963
814
        return format.open(self, _found=True)
964
815
 
965
 
    def sprout(self, url, revision_id=None, force_new_repo=False,
966
 
               possible_transports=None):
 
816
    def sprout(self, url, revision_id=None, basis=None, force_new_repo=False):
967
817
        """See BzrDir.sprout()."""
968
818
        from bzrlib.workingtree import WorkingTreeFormat2
969
819
        self._make_tail(url)
970
820
        result = self._format._initialize_for_clone(url)
 
821
        basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
971
822
        try:
972
 
            self.open_repository().clone(result, revision_id=revision_id)
 
823
            self.open_repository().clone(result, revision_id=revision_id, basis=basis_repo)
973
824
        except errors.NoRepositoryPresent:
974
825
            pass
975
826
        try:
997
848
 
998
849
    def open_repository(self):
999
850
        """See BzrDir.open_repository."""
1000
 
        from bzrlib.repofmt.weaverepo import RepositoryFormat4
 
851
        from bzrlib.repository import RepositoryFormat4
1001
852
        return RepositoryFormat4().open(self, _found=True)
1002
853
 
1003
854
 
1009
860
 
1010
861
    def open_repository(self):
1011
862
        """See BzrDir.open_repository."""
1012
 
        from bzrlib.repofmt.weaverepo import RepositoryFormat5
 
863
        from bzrlib.repository import RepositoryFormat5
1013
864
        return RepositoryFormat5().open(self, _found=True)
1014
865
 
1015
 
    def open_workingtree(self, _unsupported=False,
1016
 
            recommend_upgrade=True):
 
866
    def open_workingtree(self, _unsupported=False):
1017
867
        """See BzrDir.create_workingtree."""
1018
868
        from bzrlib.workingtree import WorkingTreeFormat2
1019
 
        wt_format = WorkingTreeFormat2()
1020
 
        # we don't warn here about upgrades; that ought to be handled for the
1021
 
        # bzrdir as a whole
1022
 
        return wt_format.open(self, _found=True)
 
869
        return WorkingTreeFormat2().open(self, _found=True)
1023
870
 
1024
871
 
1025
872
class BzrDir6(BzrDirPreSplitOut):
1030
877
 
1031
878
    def open_repository(self):
1032
879
        """See BzrDir.open_repository."""
1033
 
        from bzrlib.repofmt.weaverepo import RepositoryFormat6
 
880
        from bzrlib.repository import RepositoryFormat6
1034
881
        return RepositoryFormat6().open(self, _found=True)
1035
882
 
1036
 
    def open_workingtree(self, _unsupported=False,
1037
 
        recommend_upgrade=True):
 
883
    def open_workingtree(self, _unsupported=False):
1038
884
        """See BzrDir.create_workingtree."""
1039
 
        # we don't warn here about upgrades; that ought to be handled for the
1040
 
        # bzrdir as a whole
1041
885
        from bzrlib.workingtree import WorkingTreeFormat2
1042
886
        return WorkingTreeFormat2().open(self, _found=True)
1043
887
 
1057
901
 
1058
902
    def create_branch(self):
1059
903
        """See BzrDir.create_branch."""
1060
 
        return self._format.get_branch_format().initialize(self)
 
904
        from bzrlib.branch import BranchFormat
 
905
        return BranchFormat.get_default_format().initialize(self)
1061
906
 
1062
907
    def create_repository(self, shared=False):
1063
908
        """See BzrDir.create_repository."""
1066
911
    def create_workingtree(self, revision_id=None):
1067
912
        """See BzrDir.create_workingtree."""
1068
913
        from bzrlib.workingtree import WorkingTreeFormat
1069
 
        return self._format.workingtree_format.initialize(self, revision_id)
 
914
        return WorkingTreeFormat.get_default_format().initialize(self, revision_id)
1070
915
 
1071
916
    def destroy_workingtree(self):
1072
917
        """See BzrDir.destroy_workingtree."""
1073
 
        wt = self.open_workingtree(recommend_upgrade=False)
 
918
        wt = self.open_workingtree()
1074
919
        repository = wt.branch.repository
1075
 
        empty = repository.revision_tree(_mod_revision.NULL_REVISION)
 
920
        empty = repository.revision_tree(bzrlib.revision.NULL_REVISION)
1076
921
        wt.revert([], old_tree=empty)
1077
922
        self.destroy_workingtree_metadata()
1078
923
 
1079
924
    def destroy_workingtree_metadata(self):
1080
925
        self.transport.delete_tree('checkout')
1081
926
 
1082
 
    def find_branch_format(self):
1083
 
        """Find the branch 'format' for this bzrdir.
1084
 
 
1085
 
        This might be a synthetic object for e.g. RemoteBranch and SVN.
1086
 
        """
1087
 
        from bzrlib.branch import BranchFormat
1088
 
        return BranchFormat.find_format(self)
1089
 
 
1090
927
    def _get_mkdir_mode(self):
1091
928
        """Figure out the mode to use when creating a bzrdir subdir."""
1092
929
        temp_control = lockable_files.LockableFiles(self.transport, '',
1093
930
                                     lockable_files.TransportLock)
1094
931
        return temp_control._dir_mode
1095
932
 
1096
 
    def get_branch_reference(self):
1097
 
        """See BzrDir.get_branch_reference()."""
1098
 
        from bzrlib.branch import BranchFormat
1099
 
        format = BranchFormat.find_format(self)
1100
 
        return format.get_reference(self)
1101
 
 
1102
933
    def get_branch_transport(self, branch_format):
1103
934
        """See BzrDir.get_branch_transport()."""
1104
935
        if branch_format is None:
1156
987
                return True
1157
988
        except errors.NoRepositoryPresent:
1158
989
            pass
1159
 
        try:
1160
 
            if not isinstance(self.open_branch()._format,
1161
 
                              format.get_branch_format().__class__):
1162
 
                # the branch needs an upgrade.
1163
 
                return True
1164
 
        except errors.NotBranchError:
1165
 
            pass
1166
 
        try:
1167
 
            my_wt = self.open_workingtree(recommend_upgrade=False)
1168
 
            if not isinstance(my_wt._format,
1169
 
                              format.workingtree_format.__class__):
1170
 
                # the workingtree needs an upgrade.
1171
 
                return True
1172
 
        except (errors.NoWorkingTree, errors.NotLocalUrl):
1173
 
            pass
 
990
        # currently there are no other possible conversions for meta1 formats.
1174
991
        return False
1175
992
 
1176
993
    def open_branch(self, unsupported=False):
1177
994
        """See BzrDir.open_branch."""
1178
 
        format = self.find_branch_format()
 
995
        from bzrlib.branch import BranchFormat
 
996
        format = BranchFormat.find_format(self)
1179
997
        self._check_supported(format, unsupported)
1180
998
        return format.open(self, _found=True)
1181
999
 
1186
1004
        self._check_supported(format, unsupported)
1187
1005
        return format.open(self, _found=True)
1188
1006
 
1189
 
    def open_workingtree(self, unsupported=False,
1190
 
            recommend_upgrade=True):
 
1007
    def open_workingtree(self, unsupported=False):
1191
1008
        """See BzrDir.open_workingtree."""
1192
1009
        from bzrlib.workingtree import WorkingTreeFormat
1193
1010
        format = WorkingTreeFormat.find_format(self)
1194
 
        self._check_supported(format, unsupported,
1195
 
            recommend_upgrade,
1196
 
            basedir=self.root_transport.base)
 
1011
        self._check_supported(format, unsupported)
1197
1012
        return format.open(self, _found=True)
1198
1013
 
1199
1014
 
1226
1041
    This is a list of BzrDirFormat objects.
1227
1042
    """
1228
1043
 
1229
 
    _control_server_formats = []
1230
 
    """The registered control server formats, e.g. RemoteBzrDirs.
1231
 
 
1232
 
    This is a list of BzrDirFormat objects.
1233
 
    """
1234
 
 
1235
1044
    _lock_file_name = 'branch-lock'
1236
1045
 
1237
1046
    # _lock_class must be set in subclasses to the lock type, typ.
1238
1047
    # TransportLock or LockDir
1239
1048
 
1240
1049
    @classmethod
1241
 
    def find_format(klass, transport, _server_formats=True):
 
1050
    def find_format(klass, transport):
1242
1051
        """Return the format present at transport."""
1243
 
        if _server_formats:
1244
 
            formats = klass._control_server_formats + klass._control_formats
1245
 
        else:
1246
 
            formats = klass._control_formats
1247
 
        for format in formats:
 
1052
        for format in klass._control_formats:
1248
1053
            try:
1249
1054
                return format.probe_transport(transport)
1250
1055
            except errors.NotBranchError:
1254
1059
 
1255
1060
    @classmethod
1256
1061
    def probe_transport(klass, transport):
1257
 
        """Return the .bzrdir style format present in a directory."""
 
1062
        """Return the .bzrdir style transport present at URL."""
1258
1063
        try:
1259
1064
            format_string = transport.get(".bzr/branch-format").read()
1260
1065
        except errors.NoSuchFile:
1292
1097
        """
1293
1098
        raise NotImplementedError(self.get_converter)
1294
1099
 
1295
 
    def initialize(self, url, possible_transports=None):
 
1100
    def initialize(self, url):
1296
1101
        """Create a bzr control dir at this url and return an opened copy.
1297
1102
        
1298
1103
        Subclasses should typically override initialize_on_transport
1299
1104
        instead of this method.
1300
1105
        """
1301
 
        return self.initialize_on_transport(get_transport(url,
1302
 
                                                          possible_transports))
 
1106
        return self.initialize_on_transport(get_transport(url))
1303
1107
 
1304
1108
    def initialize_on_transport(self, transport):
1305
1109
        """Initialize a new bzrdir in the base directory of a Transport."""
1370
1174
        _found is a private parameter, do not use it.
1371
1175
        """
1372
1176
        if not _found:
1373
 
            found_format = BzrDirFormat.find_format(transport)
1374
 
            if not isinstance(found_format, self.__class__):
1375
 
                raise AssertionError("%s was asked to open %s, but it seems to need "
1376
 
                        "format %s" 
1377
 
                        % (self, transport, found_format))
 
1177
            assert isinstance(BzrDirFormat.find_format(transport),
 
1178
                              self.__class__)
1378
1179
        return self._open(transport)
1379
1180
 
1380
1181
    def _open(self, transport):
1391
1192
 
1392
1193
    @classmethod
1393
1194
    def register_control_format(klass, format):
1394
 
        """Register a format that does not use '.bzr' for its control dir.
 
1195
        """Register a format that does not use '.bzrdir' for its control dir.
1395
1196
 
1396
1197
        TODO: This should be pulled up into a 'ControlDirFormat' base class
1397
1198
        which BzrDirFormat can inherit from, and renamed to register_format 
1401
1202
        klass._control_formats.append(format)
1402
1203
 
1403
1204
    @classmethod
1404
 
    def register_control_server_format(klass, format):
1405
 
        """Register a control format for client-server environments.
1406
 
 
1407
 
        These formats will be tried before ones registered with
1408
 
        register_control_format.  This gives implementations that decide to the
1409
 
        chance to grab it before anything looks at the contents of the format
1410
 
        file.
1411
 
        """
1412
 
        klass._control_server_formats.append(format)
1413
 
 
1414
 
    @classmethod
1415
 
    @symbol_versioning.deprecated_method(symbol_versioning.zero_fourteen)
1416
1205
    def set_default_format(klass, format):
1417
 
        klass._set_default_format(format)
1418
 
 
1419
 
    @classmethod
1420
 
    def _set_default_format(klass, format):
1421
 
        """Set default format (for testing behavior of defaults only)"""
1422
1206
        klass._default_format = format
1423
1207
 
1424
1208
    def __str__(self):
1434
1218
        klass._control_formats.remove(format)
1435
1219
 
1436
1220
 
 
1221
# register BzrDirFormat as a control format
 
1222
BzrDirFormat.register_control_format(BzrDirFormat)
 
1223
 
 
1224
 
1437
1225
class BzrDirFormat4(BzrDirFormat):
1438
1226
    """Bzr dir format 4.
1439
1227
 
1481
1269
 
1482
1270
    def __return_repository_format(self):
1483
1271
        """Circular import protection."""
1484
 
        from bzrlib.repofmt.weaverepo import RepositoryFormat4
 
1272
        from bzrlib.repository import RepositoryFormat4
1485
1273
        return RepositoryFormat4()
1486
1274
    repository_format = property(__return_repository_format)
1487
1275
 
1521
1309
        Except when they are being cloned.
1522
1310
        """
1523
1311
        from bzrlib.branch import BzrBranchFormat4
1524
 
        from bzrlib.repofmt.weaverepo import RepositoryFormat5
 
1312
        from bzrlib.repository import RepositoryFormat5
1525
1313
        from bzrlib.workingtree import WorkingTreeFormat2
1526
1314
        result = (super(BzrDirFormat5, self).initialize_on_transport(transport))
1527
1315
        RepositoryFormat5().initialize(result, _internal=True)
1541
1329
 
1542
1330
    def __return_repository_format(self):
1543
1331
        """Circular import protection."""
1544
 
        from bzrlib.repofmt.weaverepo import RepositoryFormat5
 
1332
        from bzrlib.repository import RepositoryFormat5
1545
1333
        return RepositoryFormat5()
1546
1334
    repository_format = property(__return_repository_format)
1547
1335
 
1580
1368
        Except when they are being cloned.
1581
1369
        """
1582
1370
        from bzrlib.branch import BzrBranchFormat4
1583
 
        from bzrlib.repofmt.weaverepo import RepositoryFormat6
 
1371
        from bzrlib.repository import RepositoryFormat6
1584
1372
        from bzrlib.workingtree import WorkingTreeFormat2
1585
1373
        result = super(BzrDirFormat6, self).initialize_on_transport(transport)
1586
1374
        RepositoryFormat6().initialize(result, _internal=True)
1600
1388
 
1601
1389
    def __return_repository_format(self):
1602
1390
        """Circular import protection."""
1603
 
        from bzrlib.repofmt.weaverepo import RepositoryFormat6
 
1391
        from bzrlib.repository import RepositoryFormat6
1604
1392
        return RepositoryFormat6()
1605
1393
    repository_format = property(__return_repository_format)
1606
1394
 
1618
1406
 
1619
1407
    _lock_class = lockdir.LockDir
1620
1408
 
1621
 
    def __init__(self):
1622
 
        self._workingtree_format = None
1623
 
        self._branch_format = None
1624
 
 
1625
 
    def __eq__(self, other):
1626
 
        if other.__class__ is not self.__class__:
1627
 
            return False
1628
 
        if other.repository_format != self.repository_format:
1629
 
            return False
1630
 
        if other.workingtree_format != self.workingtree_format:
1631
 
            return False
1632
 
        return True
1633
 
 
1634
 
    def __ne__(self, other):
1635
 
        return not self == other
1636
 
 
1637
 
    def get_branch_format(self):
1638
 
        if self._branch_format is None:
1639
 
            from bzrlib.branch import BranchFormat
1640
 
            self._branch_format = BranchFormat.get_default_format()
1641
 
        return self._branch_format
1642
 
 
1643
 
    def set_branch_format(self, format):
1644
 
        self._branch_format = format
1645
 
 
1646
1409
    def get_converter(self, format=None):
1647
1410
        """See BzrDirFormat.get_converter()."""
1648
1411
        if format is None:
1677
1440
 
1678
1441
    repository_format = property(__return_repository_format, __set_repository_format)
1679
1442
 
1680
 
    def __get_workingtree_format(self):
1681
 
        if self._workingtree_format is None:
1682
 
            from bzrlib.workingtree import WorkingTreeFormat
1683
 
            self._workingtree_format = WorkingTreeFormat.get_default_format()
1684
 
        return self._workingtree_format
1685
 
 
1686
 
    def __set_workingtree_format(self, wt_format):
1687
 
        self._workingtree_format = wt_format
1688
 
 
1689
 
    workingtree_format = property(__get_workingtree_format,
1690
 
                                  __set_workingtree_format)
1691
 
 
1692
 
 
1693
 
# Register bzr control format
1694
 
BzrDirFormat.register_control_format(BzrDirFormat)
1695
 
 
1696
 
# Register bzr formats
 
1443
 
1697
1444
BzrDirFormat.register_format(BzrDirFormat4())
1698
1445
BzrDirFormat.register_format(BzrDirFormat5())
1699
1446
BzrDirFormat.register_format(BzrDirFormat6())
1700
1447
__default_format = BzrDirMetaFormat1()
1701
1448
BzrDirFormat.register_format(__default_format)
1702
 
BzrDirFormat._default_format = __default_format
 
1449
BzrDirFormat.set_default_format(__default_format)
 
1450
 
 
1451
 
 
1452
class BzrDirTestProviderAdapter(object):
 
1453
    """A tool to generate a suite testing multiple bzrdir formats at once.
 
1454
 
 
1455
    This is done by copying the test once for each transport and injecting
 
1456
    the transport_server, transport_readonly_server, and bzrdir_format
 
1457
    classes into each copy. Each copy is also given a new id() to make it
 
1458
    easy to identify.
 
1459
    """
 
1460
 
 
1461
    def __init__(self, transport_server, transport_readonly_server, formats):
 
1462
        self._transport_server = transport_server
 
1463
        self._transport_readonly_server = transport_readonly_server
 
1464
        self._formats = formats
 
1465
    
 
1466
    def adapt(self, test):
 
1467
        result = unittest.TestSuite()
 
1468
        for format in self._formats:
 
1469
            new_test = deepcopy(test)
 
1470
            new_test.transport_server = self._transport_server
 
1471
            new_test.transport_readonly_server = self._transport_readonly_server
 
1472
            new_test.bzrdir_format = format
 
1473
            def make_new_test_id():
 
1474
                new_id = "%s(%s)" % (new_test.id(), format.__class__.__name__)
 
1475
                return lambda: new_id
 
1476
            new_test.id = make_new_test_id()
 
1477
            result.addTest(new_test)
 
1478
        return result
1703
1479
 
1704
1480
 
1705
1481
class Converter(object):
2024
1800
 
2025
1801
    def convert(self, to_convert, pb):
2026
1802
        """See Converter.convert()."""
2027
 
        from bzrlib.repofmt.weaverepo import RepositoryFormat7
2028
 
        from bzrlib.branch import BzrBranchFormat5
2029
1803
        self.bzrdir = to_convert
2030
1804
        self.pb = pb
2031
1805
        self.count = 0
2060
1834
        # we hard code the formats here because we are converting into
2061
1835
        # the meta format. The meta format upgrader can take this to a 
2062
1836
        # future format within each component.
2063
 
        self.put_format('repository', RepositoryFormat7())
 
1837
        self.put_format('repository', bzrlib.repository.RepositoryFormat7())
2064
1838
        for entry in repository_names:
2065
1839
            self.move_entry('repository', entry)
2066
1840
 
2067
1841
        self.step('Upgrading branch      ')
2068
1842
        self.bzrdir.transport.mkdir('branch', mode=self.dir_mode)
2069
1843
        self.make_lock('branch')
2070
 
        self.put_format('branch', BzrBranchFormat5())
 
1844
        self.put_format('branch', bzrlib.branch.BzrBranchFormat5())
2071
1845
        branch_files = [('revision-history', True),
2072
1846
                        ('branch-name', True),
2073
1847
                        ('parent', False)]
2093
1867
                if name in bzrcontents:
2094
1868
                    self.bzrdir.transport.delete(name)
2095
1869
        else:
2096
 
            from bzrlib.workingtree import WorkingTreeFormat3
2097
1870
            self.step('Upgrading working tree')
2098
1871
            self.bzrdir.transport.mkdir('checkout', mode=self.dir_mode)
2099
1872
            self.make_lock('checkout')
2100
1873
            self.put_format(
2101
 
                'checkout', WorkingTreeFormat3())
 
1874
                'checkout', bzrlib.workingtree.WorkingTreeFormat3())
2102
1875
            self.bzrdir.transport.delete_multi(
2103
1876
                self.garbage_inventories, self.pb)
2104
1877
            for entry in checkout_files:
2161
1934
                self.pb.note('starting repository conversion')
2162
1935
                converter = CopyConverter(self.target_format.repository_format)
2163
1936
                converter.convert(repo, pb)
2164
 
        try:
2165
 
            branch = self.bzrdir.open_branch()
2166
 
        except errors.NotBranchError:
2167
 
            pass
2168
 
        else:
2169
 
            # TODO: conversions of Branch and Tree should be done by
2170
 
            # InterXFormat lookups
2171
 
            # Avoid circular imports
2172
 
            from bzrlib import branch as _mod_branch
2173
 
            if (branch._format.__class__ is _mod_branch.BzrBranchFormat5 and
2174
 
                self.target_format.get_branch_format().__class__ is
2175
 
                _mod_branch.BzrBranchFormat6):
2176
 
                branch_converter = _mod_branch.Converter5to6()
2177
 
                branch_converter.convert(branch)
2178
 
        try:
2179
 
            tree = self.bzrdir.open_workingtree(recommend_upgrade=False)
2180
 
        except (errors.NoWorkingTree, errors.NotLocalUrl):
2181
 
            pass
2182
 
        else:
2183
 
            # TODO: conversions of Branch and Tree should be done by
2184
 
            # InterXFormat lookups
2185
 
            if (isinstance(tree, workingtree.WorkingTree3) and
2186
 
                not isinstance(tree, workingtree_4.WorkingTree4) and
2187
 
                isinstance(self.target_format.workingtree_format,
2188
 
                    workingtree_4.WorkingTreeFormat4)):
2189
 
                workingtree_4.Converter3to4().convert(tree)
2190
1937
        return to_convert
2191
 
 
2192
 
 
2193
 
# This is not in remote.py because it's small, and needs to be registered.
2194
 
# Putting it in remote.py creates a circular import problem.
2195
 
# we can make it a lazy object if the control formats is turned into something
2196
 
# like a registry.
2197
 
class RemoteBzrDirFormat(BzrDirMetaFormat1):
2198
 
    """Format representing bzrdirs accessed via a smart server"""
2199
 
 
2200
 
    def get_format_description(self):
2201
 
        return 'bzr remote bzrdir'
2202
 
    
2203
 
    @classmethod
2204
 
    def probe_transport(klass, transport):
2205
 
        """Return a RemoteBzrDirFormat object if it looks possible."""
2206
 
        try:
2207
 
            client = transport.get_smart_client()
2208
 
        except (NotImplementedError, AttributeError,
2209
 
                errors.TransportNotPossible):
2210
 
            # no smart server, so not a branch for this format type.
2211
 
            raise errors.NotBranchError(path=transport.base)
2212
 
        else:
2213
 
            # Send a 'hello' request in protocol version one, and decline to
2214
 
            # open it if the server doesn't support our required version (2) so
2215
 
            # that the VFS-based transport will do it.
2216
 
            request = client.get_request()
2217
 
            smart_protocol = protocol.SmartClientRequestProtocolOne(request)
2218
 
            server_version = smart_protocol.query_version()
2219
 
            if server_version != 2:
2220
 
                raise errors.NotBranchError(path=transport.base)
2221
 
            return klass()
2222
 
 
2223
 
    def initialize_on_transport(self, transport):
2224
 
        try:
2225
 
            # hand off the request to the smart server
2226
 
            shared_medium = transport.get_shared_medium()
2227
 
        except errors.NoSmartMedium:
2228
 
            # TODO: lookup the local format from a server hint.
2229
 
            local_dir_format = BzrDirMetaFormat1()
2230
 
            return local_dir_format.initialize_on_transport(transport)
2231
 
        client = _SmartClient(shared_medium)
2232
 
        path = client.remote_path_from_transport(transport)
2233
 
        response = _SmartClient(shared_medium).call('BzrDirFormat.initialize',
2234
 
                                                    path)
2235
 
        assert response[0] in ('ok', ), 'unexpected response code %s' % (response,)
2236
 
        return remote.RemoteBzrDir(transport)
2237
 
 
2238
 
    def _open(self, transport):
2239
 
        return remote.RemoteBzrDir(transport)
2240
 
 
2241
 
    def __eq__(self, other):
2242
 
        if not isinstance(other, RemoteBzrDirFormat):
2243
 
            return False
2244
 
        return self.get_format_description() == other.get_format_description()
2245
 
 
2246
 
 
2247
 
BzrDirFormat.register_control_server_format(RemoteBzrDirFormat)
2248
 
 
2249
 
 
2250
 
class BzrDirFormatInfo(object):
2251
 
 
2252
 
    def __init__(self, native, deprecated, hidden):
2253
 
        self.deprecated = deprecated
2254
 
        self.native = native
2255
 
        self.hidden = hidden
2256
 
 
2257
 
 
2258
 
class BzrDirFormatRegistry(registry.Registry):
2259
 
    """Registry of user-selectable BzrDir subformats.
2260
 
    
2261
 
    Differs from BzrDirFormat._control_formats in that it provides sub-formats,
2262
 
    e.g. BzrDirMeta1 with weave repository.  Also, it's more user-oriented.
2263
 
    """
2264
 
 
2265
 
    def register_metadir(self, key,
2266
 
             repository_format, help, native=True, deprecated=False,
2267
 
             branch_format=None,
2268
 
             tree_format=None,
2269
 
             hidden=False):
2270
 
        """Register a metadir subformat.
2271
 
 
2272
 
        These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
2273
 
        by the Repository format.
2274
 
 
2275
 
        :param repository_format: The fully-qualified repository format class
2276
 
            name as a string.
2277
 
        :param branch_format: Fully-qualified branch format class name as
2278
 
            a string.
2279
 
        :param tree_format: Fully-qualified tree format class name as
2280
 
            a string.
2281
 
        """
2282
 
        # This should be expanded to support setting WorkingTree and Branch
2283
 
        # formats, once BzrDirMetaFormat1 supports that.
2284
 
        def _load(full_name):
2285
 
            mod_name, factory_name = full_name.rsplit('.', 1)
2286
 
            try:
2287
 
                mod = __import__(mod_name, globals(), locals(),
2288
 
                        [factory_name])
2289
 
            except ImportError, e:
2290
 
                raise ImportError('failed to load %s: %s' % (full_name, e))
2291
 
            try:
2292
 
                factory = getattr(mod, factory_name)
2293
 
            except AttributeError:
2294
 
                raise AttributeError('no factory %s in module %r'
2295
 
                    % (full_name, mod))
2296
 
            return factory()
2297
 
 
2298
 
        def helper():
2299
 
            bd = BzrDirMetaFormat1()
2300
 
            if branch_format is not None:
2301
 
                bd.set_branch_format(_load(branch_format))
2302
 
            if tree_format is not None:
2303
 
                bd.workingtree_format = _load(tree_format)
2304
 
            if repository_format is not None:
2305
 
                bd.repository_format = _load(repository_format)
2306
 
            return bd
2307
 
        self.register(key, helper, help, native, deprecated, hidden)
2308
 
 
2309
 
    def register(self, key, factory, help, native=True, deprecated=False,
2310
 
                 hidden=False):
2311
 
        """Register a BzrDirFormat factory.
2312
 
        
2313
 
        The factory must be a callable that takes one parameter: the key.
2314
 
        It must produce an instance of the BzrDirFormat when called.
2315
 
 
2316
 
        This function mainly exists to prevent the info object from being
2317
 
        supplied directly.
2318
 
        """
2319
 
        registry.Registry.register(self, key, factory, help, 
2320
 
            BzrDirFormatInfo(native, deprecated, hidden))
2321
 
 
2322
 
    def register_lazy(self, key, module_name, member_name, help, native=True,
2323
 
                      deprecated=False, hidden=False):
2324
 
        registry.Registry.register_lazy(self, key, module_name, member_name, 
2325
 
            help, BzrDirFormatInfo(native, deprecated, hidden))
2326
 
 
2327
 
    def set_default(self, key):
2328
 
        """Set the 'default' key to be a clone of the supplied key.
2329
 
        
2330
 
        This method must be called once and only once.
2331
 
        """
2332
 
        registry.Registry.register(self, 'default', self.get(key), 
2333
 
            self.get_help(key), info=self.get_info(key))
2334
 
 
2335
 
    def set_default_repository(self, key):
2336
 
        """Set the FormatRegistry default and Repository default.
2337
 
        
2338
 
        This is a transitional method while Repository.set_default_format
2339
 
        is deprecated.
2340
 
        """
2341
 
        if 'default' in self:
2342
 
            self.remove('default')
2343
 
        self.set_default(key)
2344
 
        format = self.get('default')()
2345
 
        assert isinstance(format, BzrDirMetaFormat1)
2346
 
 
2347
 
    def make_bzrdir(self, key):
2348
 
        return self.get(key)()
2349
 
 
2350
 
    def help_topic(self, topic):
2351
 
        output = textwrap.dedent("""\
2352
 
            Bazaar directory formats
2353
 
            ------------------------
2354
 
 
2355
 
            These formats can be used for creating branches, working trees, and
2356
 
            repositories.
2357
 
 
2358
 
            """)
2359
 
        default_help = self.get_help('default')
2360
 
        help_pairs = []
2361
 
        for key in self.keys():
2362
 
            if key == 'default':
2363
 
                continue
2364
 
            help = self.get_help(key)
2365
 
            if help == default_help:
2366
 
                default_realkey = key
2367
 
            else:
2368
 
                help_pairs.append((key, help))
2369
 
 
2370
 
        def wrapped(key, help, info):
2371
 
            if info.native:
2372
 
                help = '(native) ' + help
2373
 
            return '  %s:\n%s\n\n' % (key, 
2374
 
                    textwrap.fill(help, initial_indent='    ', 
2375
 
                    subsequent_indent='    '))
2376
 
        output += wrapped('%s/default' % default_realkey, default_help,
2377
 
                          self.get_info('default'))
2378
 
        deprecated_pairs = []
2379
 
        for key, help in help_pairs:
2380
 
            info = self.get_info(key)
2381
 
            if info.hidden:
2382
 
                continue
2383
 
            elif info.deprecated:
2384
 
                deprecated_pairs.append((key, help))
2385
 
            else:
2386
 
                output += wrapped(key, help, info)
2387
 
        if len(deprecated_pairs) > 0:
2388
 
            output += "Deprecated formats\n------------------\n\n"
2389
 
            for key, help in deprecated_pairs:
2390
 
                info = self.get_info(key)
2391
 
                output += wrapped(key, help, info)
2392
 
 
2393
 
        return output
2394
 
 
2395
 
 
2396
 
format_registry = BzrDirFormatRegistry()
2397
 
format_registry.register('weave', BzrDirFormat6,
2398
 
    'Pre-0.8 format.  Slower than knit and does not'
2399
 
    ' support checkouts or shared repositories.',
2400
 
    deprecated=True)
2401
 
format_registry.register_metadir('knit',
2402
 
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
2403
 
    'Format using knits.  Recommended for interoperation with bzr <= 0.14.',
2404
 
    branch_format='bzrlib.branch.BzrBranchFormat5',
2405
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat3')
2406
 
format_registry.register_metadir('metaweave',
2407
 
    'bzrlib.repofmt.weaverepo.RepositoryFormat7',
2408
 
    'Transitional format in 0.8.  Slower than knit.',
2409
 
    branch_format='bzrlib.branch.BzrBranchFormat5',
2410
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat3',
2411
 
    deprecated=True)
2412
 
format_registry.register_metadir('dirstate',
2413
 
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
2414
 
    help='New in 0.15: Fast local operations. Compatible with bzr 0.8 and '
2415
 
        'above when accessed over the network.',
2416
 
    branch_format='bzrlib.branch.BzrBranchFormat5',
2417
 
    # this uses bzrlib.workingtree.WorkingTreeFormat4 because importing
2418
 
    # directly from workingtree_4 triggers a circular import.
2419
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2420
 
    )
2421
 
format_registry.register_metadir('dirstate-tags',
2422
 
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
2423
 
    help='New in 0.15: Fast local operations and improved scaling for '
2424
 
        'network operations. Additionally adds support for tags.'
2425
 
        ' Incompatible with bzr < 0.15.',
2426
 
    branch_format='bzrlib.branch.BzrBranchFormat6',
2427
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2428
 
    )
2429
 
format_registry.register_metadir('dirstate-with-subtree',
2430
 
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
2431
 
    help='New in 0.15: Fast local operations and improved scaling for '
2432
 
        'network operations. Additionally adds support for versioning nested '
2433
 
        'bzr branches. Incompatible with bzr < 0.15.',
2434
 
    branch_format='bzrlib.branch.BzrBranchFormat6',
2435
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2436
 
    hidden=True,
2437
 
    )
2438
 
format_registry.set_default('dirstate')