← 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: 2009-03-06 20:42:40 UTC
  • mto: This revision was merged to the branch mainline in revision 4088.
  • Revision ID: john@arbash-meinel.com-20090306204240-mzjavv31z3gu1x7i
Fix a small bug in setup.py when an extension fails to build

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bzrdir.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""BzrDir logic. The BzrDir is the basic control directory used by bzr.
18
18
 
29
29
 
30
30
import os
31
31
import sys
32
 
import warnings
33
32
 
34
33
from bzrlib.lazy_import import lazy_import
35
34
lazy_import(globals(), """
38
37
 
39
38
import bzrlib
40
39
from bzrlib import (
41
 
    branch,
42
40
    config,
43
41
    errors,
44
42
    graph,
46
44
    lockdir,
47
45
    osutils,
48
46
    remote,
49
 
    repository,
50
47
    revision as _mod_revision,
51
48
    ui,
52
49
    urlutils,
60
57
from bzrlib.osutils import (
61
58
    sha_string,
62
59
    )
63
 
from bzrlib.push import (
64
 
    PushResult,
65
 
    )
66
 
from bzrlib.repofmt import pack_repo
67
60
from bzrlib.smart.client import _SmartClient
68
61
from bzrlib.store.versioned import WeaveStore
69
62
from bzrlib.transactions import WriteTransaction
71
64
    do_catching_redirections,
72
65
    get_transport,
73
66
    local,
 
67
    remote as remote_transport,
74
68
    )
75
69
from bzrlib.weave import Weave
76
70
""")
78
72
from bzrlib.trace import (
79
73
    mutter,
80
74
    note,
81
 
    warning,
82
75
    )
83
76
 
84
77
from bzrlib import (
85
 
    hooks,
86
78
    registry,
87
79
    symbol_versioning,
88
80
    )
101
93
        (i.e. the parent directory holding the .bzr directory).
102
94
 
103
95
    Everything in the bzrdir should have the same file permissions.
104
 
 
105
 
    :cvar hooks: An instance of BzrDirHooks.
106
96
    """
107
97
 
108
98
    def break_lock(self):
130
120
        return True
131
121
 
132
122
    def check_conversion_target(self, target_format):
133
 
        """Check that a bzrdir as a whole can be converted to a new format."""
134
 
        # The only current restriction is that the repository content can be 
135
 
        # fetched compatibly with the target.
136
123
        target_repo_format = target_format.repository_format
137
 
        try:
138
 
            self.open_repository()._format.check_conversion_target(
139
 
                target_repo_format)
140
 
        except errors.NoRepositoryPresent:
141
 
            # No repo, no problem.
142
 
            pass
 
124
        source_repo_format = self._format.repository_format
 
125
        source_repo_format.check_conversion_target(target_repo_format)
143
126
 
144
127
    @staticmethod
145
128
    def _check_supported(format, allow_unsupported,
189
172
                                       preserve_stacking=preserve_stacking)
190
173
 
191
174
    def clone_on_transport(self, transport, revision_id=None,
192
 
        force_new_repo=False, preserve_stacking=False, stacked_on=None,
193
 
        create_prefix=False, use_existing_dir=True):
 
175
                           force_new_repo=False, preserve_stacking=False,
 
176
                           stacked_on=None):
194
177
        """Clone this bzrdir and its contents to transport verbatim.
195
178
 
196
179
        :param transport: The transport for the location to produce the clone
202
185
                               even if one is available.
203
186
        :param preserve_stacking: When cloning a stacked branch, stack the
204
187
            new branch on top of the other branch's stacked-on branch.
205
 
        :param create_prefix: Create any missing directories leading up to
206
 
            to_transport.
207
 
        :param use_existing_dir: Use an existing directory if one exists.
208
188
        """
209
 
        # Overview: put together a broad description of what we want to end up
210
 
        # with; then make as few api calls as possible to do it.
211
 
        
212
 
        # We may want to create a repo/branch/tree, if we do so what format
213
 
        # would we want for each:
 
189
        transport.ensure_base()
214
190
        require_stacking = (stacked_on is not None)
215
191
        format = self.cloning_metadir(require_stacking)
216
 
        
217
 
        # Figure out what objects we want:
 
192
        result = format.initialize_on_transport(transport)
 
193
        repository_policy = None
218
194
        try:
219
195
            local_repo = self.find_repository()
220
196
        except errors.NoRepositoryPresent:
234
210
                        errors.UnstackableRepositoryFormat,
235
211
                        errors.NotStacked):
236
212
                    pass
237
 
        # Bug: We create a metadir without knowing if it can support stacking,
238
 
        # we should look up the policy needs first, or just use it as a hint,
239
 
        # or something.
 
213
 
240
214
        if local_repo:
 
215
            # may need to copy content in
 
216
            repository_policy = result.determine_repository_policy(
 
217
                force_new_repo, stacked_on, self.root_transport.base,
 
218
                require_stacking=require_stacking)
241
219
            make_working_trees = local_repo.make_working_trees()
242
 
            want_shared = local_repo.is_shared()
243
 
            repo_format_name = format.repository_format.network_name()
244
 
        else:
245
 
            make_working_trees = False
246
 
            want_shared = False
247
 
            repo_format_name = None
248
 
 
249
 
        result_repo, result, require_stacking, repository_policy = \
250
 
            format.initialize_on_transport_ex(transport,
251
 
            use_existing_dir=use_existing_dir, create_prefix=create_prefix,
252
 
            force_new_repo=force_new_repo, stacked_on=stacked_on,
253
 
            stack_on_pwd=self.root_transport.base,
254
 
            repo_format_name=repo_format_name,
255
 
            make_working_trees=make_working_trees, shared_repo=want_shared)
256
 
        if repo_format_name:
257
 
            try:
258
 
                # If the result repository is in the same place as the
259
 
                # resulting bzr dir, it will have no content, further if the
260
 
                # result is not stacked then we know all content should be
261
 
                # copied, and finally if we are copying up to a specific
262
 
                # revision_id then we can use the pending-ancestry-result which
263
 
                # does not require traversing all of history to describe it.
264
 
                if (result_repo.bzrdir.root_transport.base ==
265
 
                    result.root_transport.base and not require_stacking and
266
 
                    revision_id is not None):
267
 
                    fetch_spec = graph.PendingAncestryResult(
268
 
                        [revision_id], local_repo)
269
 
                    result_repo.fetch(local_repo, fetch_spec=fetch_spec)
270
 
                else:
271
 
                    result_repo.fetch(local_repo, revision_id=revision_id)
272
 
            finally:
273
 
                result_repo.unlock()
274
 
        else:
275
 
            if result_repo is not None:
276
 
                raise AssertionError('result_repo not None(%r)' % result_repo)
 
220
            result_repo = repository_policy.acquire_repository(
 
221
                make_working_trees, local_repo.is_shared())
 
222
            if not require_stacking and repository_policy._require_stacking:
 
223
                require_stacking = True
 
224
                result._format.require_stacking()
 
225
            result_repo.fetch(local_repo, revision_id=revision_id)
 
226
        else:
 
227
            result_repo = None
277
228
        # 1 if there is a branch present
278
229
        #   make sure its content is available in the target repository
279
230
        #   clone it.
428
379
                                    stack_on_pwd=None, require_stacking=False):
429
380
        """Return an object representing a policy to use.
430
381
 
431
 
        This controls whether a new repository is created, and the format of
432
 
        that repository, or some existing shared repository used instead.
 
382
        This controls whether a new repository is created, or a shared
 
383
        repository used instead.
433
384
 
434
385
        If stack_on is supplied, will not seek a containing shared repo.
435
386
 
444
395
            stack_on_pwd = None
445
396
            config = found_bzrdir.get_config()
446
397
            stop = False
447
 
            stack_on = config.get_default_stack_on()
448
 
            if stack_on is not None:
449
 
                stack_on_pwd = found_bzrdir.root_transport.base
450
 
                stop = True
 
398
            if config is not None:
 
399
                stack_on = config.get_default_stack_on()
 
400
                if stack_on is not None:
 
401
                    stack_on_pwd = found_bzrdir.root_transport.base
 
402
                    stop = True
 
403
                    note('Using default stacking branch %s at %s', stack_on,
 
404
                         stack_on_pwd)
451
405
            # does it have a repository ?
452
406
            try:
453
407
                repository = found_bzrdir.open_repository()
456
410
            else:
457
411
                if ((found_bzrdir.root_transport.base !=
458
412
                     self.root_transport.base) and not repository.is_shared()):
459
 
                    # Don't look higher, can't use a higher shared repo.
460
413
                    repository = None
461
 
                    stop = True
462
414
                else:
463
415
                    stop = True
464
416
            if not stop:
488
440
    def _find_or_create_repository(self, force_new_repo):
489
441
        """Create a new repository if needed, returning the repository."""
490
442
        policy = self.determine_repository_policy(force_new_repo)
491
 
        return policy.acquire_repository()[0]
 
443
        return policy.acquire_repository()
492
444
 
493
445
    @staticmethod
494
446
    def create_branch_convenience(base, force_new_repo=False,
585
537
            # permissions as the .bzr directory (probably a bug in copy_tree)
586
538
            old_path = self.root_transport.abspath('.bzr')
587
539
            new_path = self.root_transport.abspath('backup.bzr')
588
 
            ui.ui_factory.note('making backup of %s\n  to %s' % (old_path, new_path,))
 
540
            pb.note('making backup of %s' % (old_path,))
 
541
            pb.note('  to %s' % (new_path,))
589
542
            self.root_transport.copy_tree('.bzr', 'backup.bzr')
590
543
            return (old_path, new_path)
591
544
        finally:
778
731
        raise NotImplementedError(self.get_workingtree_transport)
779
732
 
780
733
    def get_config(self):
781
 
        """Get configuration for this BzrDir."""
782
 
        return config.BzrDirConfig(self)
783
 
 
784
 
    def _get_config(self):
785
 
        """By default, no configuration is available."""
786
 
        return None
 
734
        if getattr(self, '_get_config', None) is None:
 
735
            return None
 
736
        return self._get_config()
787
737
 
788
738
    def __init__(self, _transport, _format):
789
739
        """Initialize a Bzr control dir object.
851
801
        :param transport: Transport containing the bzrdir.
852
802
        :param _unsupported: private.
853
803
        """
854
 
        for hook in BzrDir.hooks['pre_open']:
855
 
            hook(transport)
856
804
        # Keep initial base since 'transport' may be modified while following
857
805
        # the redirections.
858
806
        base = transport.base
878
826
        BzrDir._check_supported(format, _unsupported)
879
827
        return format.open(transport, _found=True)
880
828
 
881
 
    def open_branch(self, unsupported=False, ignore_fallbacks=False):
 
829
    def open_branch(self, unsupported=False):
882
830
        """Open the branch object at this BzrDir if one is present.
883
831
 
884
832
        If unsupported is True, then no longer supported branch formats can
1059
1007
        result_format = self._format.__class__()
1060
1008
        try:
1061
1009
            try:
1062
 
                branch = self.open_branch(ignore_fallbacks=True)
 
1010
                branch = self.open_branch()
1063
1011
                source_repository = branch.repository
1064
1012
                result_format._branch_format = branch._format
1065
1013
            except errors.NotBranchError:
1102
1050
        """
1103
1051
        format, repository = self._cloning_metadir()
1104
1052
        if format._workingtree_format is None:
1105
 
            # No tree in self.
1106
1053
            if repository is None:
1107
 
                # No repository either
1108
1054
                return format
1109
 
            # We have a repository, so set a working tree? (Why? This seems to
1110
 
            # contradict the stated return value in the docstring).
1111
1055
            tree_format = repository._format._matchingbzrdir.workingtree_format
1112
1056
            format.workingtree_format = tree_format.__class__()
1113
1057
        if require_stacking:
1170
1114
                    source_repository = None
1171
1115
        repository_policy = result.determine_repository_policy(
1172
1116
            force_new_repo, stacked_branch_url, require_stacking=stacked)
1173
 
        result_repo, is_new_repo = repository_policy.acquire_repository()
1174
 
        if is_new_repo and revision_id is not None and not stacked:
1175
 
            fetch_spec = graph.PendingAncestryResult(
1176
 
                [revision_id], source_repository)
1177
 
        else:
1178
 
            fetch_spec = None
 
1117
        result_repo = repository_policy.acquire_repository()
1179
1118
        if source_repository is not None:
1180
1119
            # Fetch while stacked to prevent unstacked fetch from
1181
1120
            # Branch.sprout.
1182
 
            if fetch_spec is None:
1183
 
                result_repo.fetch(source_repository, revision_id=revision_id)
1184
 
            else:
1185
 
                result_repo.fetch(source_repository, fetch_spec=fetch_spec)
 
1121
            result_repo.fetch(source_repository, revision_id=revision_id)
1186
1122
 
1187
1123
        if source_branch is None:
1188
1124
            # this is for sprouting a bzrdir without a branch; is that
1240
1176
                    basis.unlock()
1241
1177
        return result
1242
1178
 
1243
 
    def push_branch(self, source, revision_id=None, overwrite=False, 
1244
 
        remember=False, create_prefix=False):
1245
 
        """Push the source branch into this BzrDir."""
1246
 
        br_to = None
1247
 
        # If we can open a branch, use its direct repository, otherwise see
1248
 
        # if there is a repository without a branch.
1249
 
        try:
1250
 
            br_to = self.open_branch()
1251
 
        except errors.NotBranchError:
1252
 
            # Didn't find a branch, can we find a repository?
1253
 
            repository_to = self.find_repository()
1254
 
        else:
1255
 
            # Found a branch, so we must have found a repository
1256
 
            repository_to = br_to.repository
1257
 
 
1258
 
        push_result = PushResult()
1259
 
        push_result.source_branch = source
1260
 
        if br_to is None:
1261
 
            # We have a repository but no branch, copy the revisions, and then
1262
 
            # create a branch.
1263
 
            repository_to.fetch(source.repository, revision_id=revision_id)
1264
 
            br_to = source.clone(self, revision_id=revision_id)
1265
 
            if source.get_push_location() is None or remember:
1266
 
                source.set_push_location(br_to.base)
1267
 
            push_result.stacked_on = None
1268
 
            push_result.branch_push_result = None
1269
 
            push_result.old_revno = None
1270
 
            push_result.old_revid = _mod_revision.NULL_REVISION
1271
 
            push_result.target_branch = br_to
1272
 
            push_result.master_branch = None
1273
 
            push_result.workingtree_updated = False
1274
 
        else:
1275
 
            # We have successfully opened the branch, remember if necessary:
1276
 
            if source.get_push_location() is None or remember:
1277
 
                source.set_push_location(br_to.base)
1278
 
            try:
1279
 
                tree_to = self.open_workingtree()
1280
 
            except errors.NotLocalUrl:
1281
 
                push_result.branch_push_result = source.push(br_to, 
1282
 
                    overwrite, stop_revision=revision_id)
1283
 
                push_result.workingtree_updated = False
1284
 
            except errors.NoWorkingTree:
1285
 
                push_result.branch_push_result = source.push(br_to,
1286
 
                    overwrite, stop_revision=revision_id)
1287
 
                push_result.workingtree_updated = None # Not applicable
1288
 
            else:
1289
 
                tree_to.lock_write()
1290
 
                try:
1291
 
                    push_result.branch_push_result = source.push(
1292
 
                        tree_to.branch, overwrite, stop_revision=revision_id)
1293
 
                    tree_to.update()
1294
 
                finally:
1295
 
                    tree_to.unlock()
1296
 
                push_result.workingtree_updated = True
1297
 
            push_result.old_revno = push_result.branch_push_result.old_revno
1298
 
            push_result.old_revid = push_result.branch_push_result.old_revid
1299
 
            push_result.target_branch = \
1300
 
                push_result.branch_push_result.target_branch
1301
 
        return push_result
1302
 
 
1303
 
 
1304
 
class BzrDirHooks(hooks.Hooks):
1305
 
    """Hooks for BzrDir operations."""
1306
 
 
1307
 
    def __init__(self):
1308
 
        """Create the default hooks."""
1309
 
        hooks.Hooks.__init__(self)
1310
 
        self.create_hook(hooks.HookPoint('pre_open',
1311
 
            "Invoked before attempting to open a BzrDir with the transport "
1312
 
            "that the open will use.", (1, 14), None))
1313
 
 
1314
 
# install the default hooks
1315
 
BzrDir.hooks = BzrDirHooks()
1316
 
 
1317
1179
 
1318
1180
class BzrDirPreSplitOut(BzrDir):
1319
1181
    """A common class for the all-in-one formats."""
1392
1254
        # that can do wonky stuff here, and that only
1393
1255
        # happens for creating checkouts, which cannot be
1394
1256
        # done on this format anyway. So - acceptable wart.
1395
 
        if hardlink:
1396
 
            warning("can't support hardlinked working trees in %r"
1397
 
                % (self,))
1398
1257
        try:
1399
1258
            result = self.open_workingtree(recommend_upgrade=False)
1400
1259
        except errors.NoSuchFile:
1465
1324
            format = BzrDirFormat.get_default_format()
1466
1325
        return not isinstance(self._format, format.__class__)
1467
1326
 
1468
 
    def open_branch(self, unsupported=False, ignore_fallbacks=False):
 
1327
    def open_branch(self, unsupported=False):
1469
1328
        """See BzrDir.open_branch."""
1470
1329
        from bzrlib.branch import BzrBranchFormat4
1471
1330
        format = BzrBranchFormat4()
1537
1396
    This is a deprecated format and may be removed after sept 2006.
1538
1397
    """
1539
1398
 
1540
 
    def has_workingtree(self):
1541
 
        """See BzrDir.has_workingtree."""
1542
 
        return True
1543
 
    
1544
1399
    def open_repository(self):
1545
1400
        """See BzrDir.open_repository."""
1546
1401
        from bzrlib.repofmt.weaverepo import RepositoryFormat5
1562
1417
    This is a deprecated format and may be removed after sept 2006.
1563
1418
    """
1564
1419
 
1565
 
    def has_workingtree(self):
1566
 
        """See BzrDir.has_workingtree."""
1567
 
        return True
1568
 
    
1569
1420
    def open_repository(self):
1570
1421
        """See BzrDir.open_repository."""
1571
1422
        from bzrlib.repofmt.weaverepo import RepositoryFormat6
1649
1500
 
1650
1501
    def get_branch_transport(self, branch_format):
1651
1502
        """See BzrDir.get_branch_transport()."""
1652
 
        # XXX: this shouldn't implicitly create the directory if it's just
1653
 
        # promising to get a transport -- mbp 20090727
1654
1503
        if branch_format is None:
1655
1504
            return self.transport.clone('branch')
1656
1505
        try:
1691
1540
            pass
1692
1541
        return self.transport.clone('checkout')
1693
1542
 
1694
 
    def has_workingtree(self):
1695
 
        """Tell if this bzrdir contains a working tree.
1696
 
 
1697
 
        This will still raise an exception if the bzrdir has a workingtree that
1698
 
        is remote & inaccessible.
1699
 
 
1700
 
        Note: if you're going to open the working tree, you should just go
1701
 
        ahead and try, and not ask permission first.
1702
 
        """
1703
 
        from bzrlib.workingtree import WorkingTreeFormat
1704
 
        try:
1705
 
            WorkingTreeFormat.find_format(self)
1706
 
        except errors.NoWorkingTree:
1707
 
            return False
1708
 
        return True
1709
 
 
1710
1543
    def needs_format_conversion(self, format=None):
1711
1544
        """See BzrDir.needs_format_conversion()."""
1712
1545
        if format is None:
1742
1575
            pass
1743
1576
        return False
1744
1577
 
1745
 
    def open_branch(self, unsupported=False, ignore_fallbacks=False):
 
1578
    def open_branch(self, unsupported=False):
1746
1579
        """See BzrDir.open_branch."""
1747
1580
        format = self.find_branch_format()
1748
1581
        self._check_supported(format, unsupported)
1749
 
        return format.open(self, _found=True, ignore_fallbacks=ignore_fallbacks)
 
1582
        return format.open(self, _found=True)
1750
1583
 
1751
1584
    def open_repository(self, unsupported=False):
1752
1585
        """See BzrDir.open_repository."""
1766
1599
        return format.open(self, _found=True)
1767
1600
 
1768
1601
    def _get_config(self):
1769
 
        return config.TransportConfig(self.transport, 'control.conf')
 
1602
        return config.BzrDirConfig(self.transport)
1770
1603
 
1771
1604
 
1772
1605
class BzrDirFormat(object):
1828
1661
    def probe_transport(klass, transport):
1829
1662
        """Return the .bzrdir style format present in a directory."""
1830
1663
        try:
1831
 
            format_string = transport.get_bytes(".bzr/branch-format")
 
1664
            format_string = transport.get(".bzr/branch-format").read()
1832
1665
        except errors.NoSuchFile:
1833
1666
            raise errors.NotBranchError(path=transport.base)
1834
1667
 
1867
1700
    def initialize(self, url, possible_transports=None):
1868
1701
        """Create a bzr control dir at this url and return an opened copy.
1869
1702
 
1870
 
        While not deprecated, this method is very specific and its use will
1871
 
        lead to many round trips to setup a working environment. See
1872
 
        initialize_on_transport_ex for a [nearly] all-in-one method.
1873
 
 
1874
1703
        Subclasses should typically override initialize_on_transport
1875
1704
        instead of this method.
1876
1705
        """
1895
1724
            self._supply_sub_formats_to(remote_format)
1896
1725
            return remote_format.initialize_on_transport(transport)
1897
1726
 
1898
 
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
1899
 
        create_prefix=False, force_new_repo=False, stacked_on=None,
1900
 
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
1901
 
        shared_repo=False, vfs_only=False):
1902
 
        """Create this format on transport.
1903
 
 
1904
 
        The directory to initialize will be created.
1905
 
 
1906
 
        :param force_new_repo: Do not use a shared repository for the target,
1907
 
                               even if one is available.
1908
 
        :param create_prefix: Create any missing directories leading up to
1909
 
            to_transport.
1910
 
        :param use_existing_dir: Use an existing directory if one exists.
1911
 
        :param stacked_on: A url to stack any created branch on, None to follow
1912
 
            any target stacking policy.
1913
 
        :param stack_on_pwd: If stack_on is relative, the location it is
1914
 
            relative to.
1915
 
        :param repo_format_name: If non-None, a repository will be
1916
 
            made-or-found. Should none be found, or if force_new_repo is True
1917
 
            the repo_format_name is used to select the format of repository to
1918
 
            create.
1919
 
        :param make_working_trees: Control the setting of make_working_trees
1920
 
            for a new shared repository when one is made. None to use whatever
1921
 
            default the format has.
1922
 
        :param shared_repo: Control whether made repositories are shared or
1923
 
            not.
1924
 
        :param vfs_only: If True do not attempt to use a smart server
1925
 
        :return: repo, bzrdir, require_stacking, repository_policy. repo is
1926
 
            None if none was created or found, bzrdir is always valid.
1927
 
            require_stacking is the result of examining the stacked_on
1928
 
            parameter and any stacking policy found for the target.
1929
 
        """
1930
 
        if not vfs_only:
1931
 
            # Try to hand off to a smart server 
1932
 
            try:
1933
 
                client_medium = transport.get_smart_medium()
1934
 
            except errors.NoSmartMedium:
1935
 
                pass
1936
 
            else:
1937
 
                # TODO: lookup the local format from a server hint.
1938
 
                remote_dir_format = RemoteBzrDirFormat()
1939
 
                remote_dir_format._network_name = self.network_name()
1940
 
                self._supply_sub_formats_to(remote_dir_format)
1941
 
                return remote_dir_format.initialize_on_transport_ex(transport,
1942
 
                    use_existing_dir=use_existing_dir, create_prefix=create_prefix,
1943
 
                    force_new_repo=force_new_repo, stacked_on=stacked_on,
1944
 
                    stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
1945
 
                    make_working_trees=make_working_trees, shared_repo=shared_repo)
1946
 
        # XXX: Refactor the create_prefix/no_create_prefix code into a
1947
 
        #      common helper function
1948
 
        # The destination may not exist - if so make it according to policy.
1949
 
        def make_directory(transport):
1950
 
            transport.mkdir('.')
1951
 
            return transport
1952
 
        def redirected(transport, e, redirection_notice):
1953
 
            note(redirection_notice)
1954
 
            return transport._redirected_to(e.source, e.target)
1955
 
        try:
1956
 
            transport = do_catching_redirections(make_directory, transport,
1957
 
                redirected)
1958
 
        except errors.FileExists:
1959
 
            if not use_existing_dir:
1960
 
                raise
1961
 
        except errors.NoSuchFile:
1962
 
            if not create_prefix:
1963
 
                raise
1964
 
            transport.create_prefix()
1965
 
 
1966
 
        require_stacking = (stacked_on is not None)
1967
 
        # Now the target directory exists, but doesn't have a .bzr
1968
 
        # directory. So we need to create it, along with any work to create
1969
 
        # all of the dependent branches, etc.
1970
 
 
1971
 
        result = self.initialize_on_transport(transport)
1972
 
        if repo_format_name:
1973
 
            try:
1974
 
                # use a custom format
1975
 
                result._format.repository_format = \
1976
 
                    repository.network_format_registry.get(repo_format_name)
1977
 
            except AttributeError:
1978
 
                # The format didn't permit it to be set.
1979
 
                pass
1980
 
            # A repository is desired, either in-place or shared.
1981
 
            repository_policy = result.determine_repository_policy(
1982
 
                force_new_repo, stacked_on, stack_on_pwd,
1983
 
                require_stacking=require_stacking)
1984
 
            result_repo, is_new_repo = repository_policy.acquire_repository(
1985
 
                make_working_trees, shared_repo)
1986
 
            if not require_stacking and repository_policy._require_stacking:
1987
 
                require_stacking = True
1988
 
                result._format.require_stacking()
1989
 
            result_repo.lock_write()
1990
 
        else:
1991
 
            result_repo = None
1992
 
            repository_policy = None
1993
 
        return result_repo, result, require_stacking, repository_policy
1994
 
 
1995
1727
    def _initialize_on_transport_vfs(self, transport):
1996
1728
        """Initialize a new bzrdir using VFS calls.
1997
1729
 
2209
1941
    repository_format = property(__return_repository_format)
2210
1942
 
2211
1943
 
2212
 
class BzrDirFormatAllInOne(BzrDirFormat):
2213
 
    """Common class for formats before meta-dirs."""
2214
 
 
2215
 
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
2216
 
        create_prefix=False, force_new_repo=False, stacked_on=None,
2217
 
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
2218
 
        shared_repo=False):
2219
 
        """See BzrDirFormat.initialize_on_transport_ex."""
2220
 
        require_stacking = (stacked_on is not None)
2221
 
        # Format 5 cannot stack, but we've been asked to - actually init
2222
 
        # a Meta1Dir
2223
 
        if require_stacking:
2224
 
            format = BzrDirMetaFormat1()
2225
 
            return format.initialize_on_transport_ex(transport,
2226
 
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
2227
 
                force_new_repo=force_new_repo, stacked_on=stacked_on,
2228
 
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
2229
 
                make_working_trees=make_working_trees, shared_repo=shared_repo)
2230
 
        return BzrDirFormat.initialize_on_transport_ex(self, transport,
2231
 
            use_existing_dir=use_existing_dir, create_prefix=create_prefix,
2232
 
            force_new_repo=force_new_repo, stacked_on=stacked_on,
2233
 
            stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
2234
 
            make_working_trees=make_working_trees, shared_repo=shared_repo)
2235
 
 
2236
 
 
2237
 
class BzrDirFormat5(BzrDirFormatAllInOne):
 
1944
class BzrDirFormat5(BzrDirFormat):
2238
1945
    """Bzr control format 5.
2239
1946
 
2240
1947
    This format is a combined format for working tree, branch and repository.
2295
2002
    repository_format = property(__return_repository_format)
2296
2003
 
2297
2004
 
2298
 
class BzrDirFormat6(BzrDirFormatAllInOne):
 
2005
class BzrDirFormat6(BzrDirFormat):
2299
2006
    """Bzr control format 6.
2300
2007
 
2301
2008
    This format is a combined format for working tree, branch and repository.
2394
2101
    def set_branch_format(self, format):
2395
2102
        self._branch_format = format
2396
2103
 
2397
 
    def require_stacking(self, stack_on=None, possible_transports=None,
2398
 
            _skip_repo=False):
2399
 
        """We have a request to stack, try to ensure the formats support it.
2400
 
 
2401
 
        :param stack_on: If supplied, it is the URL to a branch that we want to
2402
 
            stack on. Check to see if that format supports stacking before
2403
 
            forcing an upgrade.
2404
 
        """
2405
 
        # Stacking is desired. requested by the target, but does the place it
2406
 
        # points at support stacking? If it doesn't then we should
2407
 
        # not implicitly upgrade. We check this here.
2408
 
        new_repo_format = None
2409
 
        new_branch_format = None
2410
 
 
2411
 
        # a bit of state for get_target_branch so that we don't try to open it
2412
 
        # 2 times, for both repo *and* branch
2413
 
        target = [None, False, None] # target_branch, checked, upgrade anyway
2414
 
        def get_target_branch():
2415
 
            if target[1]:
2416
 
                # We've checked, don't check again
2417
 
                return target
2418
 
            if stack_on is None:
2419
 
                # No target format, that means we want to force upgrading
2420
 
                target[:] = [None, True, True]
2421
 
                return target
2422
 
            try:
2423
 
                target_dir = BzrDir.open(stack_on,
2424
 
                    possible_transports=possible_transports)
2425
 
            except errors.NotBranchError:
2426
 
                # Nothing there, don't change formats
2427
 
                target[:] = [None, True, False]
2428
 
                return target
2429
 
            except errors.JailBreak:
2430
 
                # JailBreak, JFDI and upgrade anyway
2431
 
                target[:] = [None, True, True]
2432
 
                return target
2433
 
            try:
2434
 
                target_branch = target_dir.open_branch()
2435
 
            except errors.NotBranchError:
2436
 
                # No branch, don't upgrade formats
2437
 
                target[:] = [None, True, False]
2438
 
                return target
2439
 
            target[:] = [target_branch, True, False]
2440
 
            return target
2441
 
 
2442
 
        if (not _skip_repo and
2443
 
                 not self.repository_format.supports_external_lookups):
2444
 
            # We need to upgrade the Repository.
2445
 
            target_branch, _, do_upgrade = get_target_branch()
2446
 
            if target_branch is None:
2447
 
                # We don't have a target branch, should we upgrade anyway?
2448
 
                if do_upgrade:
2449
 
                    # stack_on is inaccessible, JFDI.
2450
 
                    # TODO: bad monkey, hard-coded formats...
2451
 
                    if self.repository_format.rich_root_data:
2452
 
                        new_repo_format = pack_repo.RepositoryFormatKnitPack5RichRoot()
2453
 
                    else:
2454
 
                        new_repo_format = pack_repo.RepositoryFormatKnitPack5()
2455
 
            else:
2456
 
                # If the target already supports stacking, then we know the
2457
 
                # project is already able to use stacking, so auto-upgrade
2458
 
                # for them
2459
 
                new_repo_format = target_branch.repository._format
2460
 
                if not new_repo_format.supports_external_lookups:
2461
 
                    # target doesn't, source doesn't, so don't auto upgrade
2462
 
                    # repo
2463
 
                    new_repo_format = None
2464
 
            if new_repo_format is not None:
2465
 
                self.repository_format = new_repo_format
2466
 
                note('Source repository format does not support stacking,'
2467
 
                     ' using format:\n  %s',
2468
 
                     new_repo_format.get_format_description())
2469
 
 
 
2104
    def require_stacking(self):
2470
2105
        if not self.get_branch_format().supports_stacking():
2471
 
            # We just checked the repo, now lets check if we need to
2472
 
            # upgrade the branch format
2473
 
            target_branch, _, do_upgrade = get_target_branch()
2474
 
            if target_branch is None:
2475
 
                if do_upgrade:
2476
 
                    # TODO: bad monkey, hard-coded formats...
2477
 
                    new_branch_format = branch.BzrBranchFormat7()
 
2106
            # We need to make a stacked branch, but the default format for the
 
2107
            # target doesn't support stacking.  So force a branch that *can*
 
2108
            # support stacking.
 
2109
            from bzrlib.branch import BzrBranchFormat7
 
2110
            branch_format = BzrBranchFormat7()
 
2111
            self.set_branch_format(branch_format)
 
2112
            mutter("using %r for stacking" % (branch_format,))
 
2113
            from bzrlib.repofmt import pack_repo
 
2114
            if self.repository_format.rich_root_data:
 
2115
                bzrdir_format_name = '1.6.1-rich-root'
 
2116
                repo_format = pack_repo.RepositoryFormatKnitPack5RichRoot()
2478
2117
            else:
2479
 
                new_branch_format = target_branch._format
2480
 
                if not new_branch_format.supports_stacking():
2481
 
                    new_branch_format = None
2482
 
            if new_branch_format is not None:
2483
 
                # Does support stacking, use its format.
2484
 
                self.set_branch_format(new_branch_format)
2485
 
                note('Source branch format does not support stacking,'
2486
 
                     ' using format:\n  %s',
2487
 
                     new_branch_format.get_format_description())
 
2118
                bzrdir_format_name = '1.6'
 
2119
                repo_format = pack_repo.RepositoryFormatKnitPack5()
 
2120
            note('Source format does not support stacking, using format:'
 
2121
                 ' \'%s\'\n  %s\n',
 
2122
                 bzrdir_format_name, repo_format.get_format_description())
 
2123
            self.repository_format = repo_format
2488
2124
 
2489
2125
    def get_converter(self, format=None):
2490
2126
        """See BzrDirFormat.get_converter()."""
2508
2144
 
2509
2145
    def _open(self, transport):
2510
2146
        """See BzrDirFormat._open."""
2511
 
        # Create a new format instance because otherwise initialisation of new
2512
 
        # metadirs share the global default format object leading to alias
2513
 
        # problems.
2514
 
        format = BzrDirMetaFormat1()
2515
 
        self._supply_sub_formats_to(format)
2516
 
        return BzrDirMeta1(transport, format)
 
2147
        return BzrDirMeta1(transport, self)
2517
2148
 
2518
2149
    def __return_repository_format(self):
2519
2150
        """Circular import protection."""
2610
2241
    def convert(self, to_convert, pb):
2611
2242
        """See Converter.convert()."""
2612
2243
        self.bzrdir = to_convert
2613
 
        if pb is not None:
2614
 
            warnings.warn("pb parameter to convert() is deprecated")
2615
 
        self.pb = ui.ui_factory.nested_progress_bar()
2616
 
        try:
2617
 
            ui.ui_factory.note('starting upgrade from format 4 to 5')
2618
 
            if isinstance(self.bzrdir.transport, local.LocalTransport):
2619
 
                self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
2620
 
            self._convert_to_weaves()
2621
 
            return BzrDir.open(self.bzrdir.root_transport.base)
2622
 
        finally:
2623
 
            self.pb.finished()
 
2244
        self.pb = pb
 
2245
        self.pb.note('starting upgrade from format 4 to 5')
 
2246
        if isinstance(self.bzrdir.transport, local.LocalTransport):
 
2247
            self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
 
2248
        self._convert_to_weaves()
 
2249
        return BzrDir.open(self.bzrdir.root_transport.base)
2624
2250
 
2625
2251
    def _convert_to_weaves(self):
2626
 
        ui.ui_factory.note('note: upgrade may be faster if all store files are ungzipped first')
 
2252
        self.pb.note('note: upgrade may be faster if all store files are ungzipped first')
2627
2253
        try:
2628
2254
            # TODO permissions
2629
2255
            stat = self.bzrdir.transport.stat('weaves')
2657
2283
        self.pb.clear()
2658
2284
        self._write_all_weaves()
2659
2285
        self._write_all_revs()
2660
 
        ui.ui_factory.note('upgraded to weaves:')
2661
 
        ui.ui_factory.note('  %6d revisions and inventories' % len(self.revisions))
2662
 
        ui.ui_factory.note('  %6d revisions not present' % len(self.absent_revisions))
2663
 
        ui.ui_factory.note('  %6d texts' % self.text_count)
 
2286
        self.pb.note('upgraded to weaves:')
 
2287
        self.pb.note('  %6d revisions and inventories', len(self.revisions))
 
2288
        self.pb.note('  %6d revisions not present', len(self.absent_revisions))
 
2289
        self.pb.note('  %6d texts', self.text_count)
2664
2290
        self._cleanup_spare_files_after_format4()
2665
2291
        self.branch._transport.put_bytes(
2666
2292
            'branch-format',
2734
2360
                       len(self.known_revisions))
2735
2361
        if not self.branch.repository.has_revision(rev_id):
2736
2362
            self.pb.clear()
2737
 
            ui.ui_factory.note('revision {%s} not present in branch; '
2738
 
                         'will be converted as a ghost' %
 
2363
            self.pb.note('revision {%s} not present in branch; '
 
2364
                         'will be converted as a ghost',
2739
2365
                         rev_id)
2740
2366
            self.absent_revisions.add(rev_id)
2741
2367
        else:
2810
2436
        self.snapshot_ie(previous_entries, ie, w, rev_id)
2811
2437
        del ie.text_id
2812
2438
 
 
2439
    @symbol_versioning.deprecated_method(symbol_versioning.one_one)
 
2440
    def get_parents(self, revision_ids):
 
2441
        for revision_id in revision_ids:
 
2442
            yield self.revisions[revision_id].parent_ids
 
2443
 
2813
2444
    def get_parent_map(self, revision_ids):
2814
 
        """See graph.StackedParentsProvider.get_parent_map"""
 
2445
        """See graph._StackedParentsProvider.get_parent_map"""
2815
2446
        return dict((revision_id, self.revisions[revision_id])
2816
2447
                    for revision_id in revision_ids
2817
2448
                     if revision_id in self.revisions)
2867
2498
    def convert(self, to_convert, pb):
2868
2499
        """See Converter.convert()."""
2869
2500
        self.bzrdir = to_convert
2870
 
        pb = ui.ui_factory.nested_progress_bar()
2871
 
        try:
2872
 
            ui.ui_factory.note('starting upgrade from format 5 to 6')
2873
 
            self._convert_to_prefixed()
2874
 
            return BzrDir.open(self.bzrdir.root_transport.base)
2875
 
        finally:
2876
 
            pb.finished()
 
2501
        self.pb = pb
 
2502
        self.pb.note('starting upgrade from format 5 to 6')
 
2503
        self._convert_to_prefixed()
 
2504
        return BzrDir.open(self.bzrdir.root_transport.base)
2877
2505
 
2878
2506
    def _convert_to_prefixed(self):
2879
2507
        from bzrlib.store import TransportStore
2880
2508
        self.bzrdir.transport.delete('branch-format')
2881
2509
        for store_name in ["weaves", "revision-store"]:
2882
 
            ui.ui_factory.note("adding prefixes to %s" % store_name)
 
2510
            self.pb.note("adding prefixes to %s" % store_name)
2883
2511
            store_transport = self.bzrdir.transport.clone(store_name)
2884
2512
            store = TransportStore(store_transport, prefixed=True)
2885
2513
            for urlfilename in store_transport.list_dir('.'):
2912
2540
        from bzrlib.repofmt.weaverepo import RepositoryFormat7
2913
2541
        from bzrlib.branch import BzrBranchFormat5
2914
2542
        self.bzrdir = to_convert
2915
 
        self.pb = ui.ui_factory.nested_progress_bar()
 
2543
        self.pb = pb
2916
2544
        self.count = 0
2917
2545
        self.total = 20 # the steps we know about
2918
2546
        self.garbage_inventories = []
2919
2547
        self.dir_mode = self.bzrdir._get_dir_mode()
2920
2548
        self.file_mode = self.bzrdir._get_file_mode()
2921
2549
 
2922
 
        ui.ui_factory.note('starting upgrade from format 6 to metadir')
 
2550
        self.pb.note('starting upgrade from format 6 to metadir')
2923
2551
        self.bzrdir.transport.put_bytes(
2924
2552
                'branch-format',
2925
2553
                "Converting to format 6",
2975
2603
        else:
2976
2604
            has_checkout = True
2977
2605
        if not has_checkout:
2978
 
            ui.ui_factory.note('No working tree.')
 
2606
            self.pb.note('No working tree.')
2979
2607
            # If some checkout files are there, we may as well get rid of them.
2980
2608
            for name, mandatory in checkout_files:
2981
2609
                if name in bzrcontents:
2998
2626
            'branch-format',
2999
2627
            BzrDirMetaFormat1().get_format_string(),
3000
2628
            mode=self.file_mode)
3001
 
        self.pb.finished()
3002
2629
        return BzrDir.open(self.bzrdir.root_transport.base)
3003
2630
 
3004
2631
    def make_lock(self, name):
3040
2667
    def convert(self, to_convert, pb):
3041
2668
        """See Converter.convert()."""
3042
2669
        self.bzrdir = to_convert
3043
 
        self.pb = ui.ui_factory.nested_progress_bar()
 
2670
        self.pb = pb
3044
2671
        self.count = 0
3045
2672
        self.total = 1
3046
2673
        self.step('checking repository format')
3051
2678
        else:
3052
2679
            if not isinstance(repo._format, self.target_format.repository_format.__class__):
3053
2680
                from bzrlib.repository import CopyConverter
3054
 
                ui.ui_factory.note('starting repository conversion')
 
2681
                self.pb.note('starting repository conversion')
3055
2682
                converter = CopyConverter(self.target_format.repository_format)
3056
2683
                converter.convert(repo, pb)
3057
2684
        try:
3068
2695
            while old != new:
3069
2696
                if (old == _mod_branch.BzrBranchFormat5 and
3070
2697
                    new in (_mod_branch.BzrBranchFormat6,
3071
 
                        _mod_branch.BzrBranchFormat7,
3072
 
                        _mod_branch.BzrBranchFormat8)):
 
2698
                        _mod_branch.BzrBranchFormat7)):
3073
2699
                    branch_converter = _mod_branch.Converter5to6()
3074
2700
                elif (old == _mod_branch.BzrBranchFormat6 and
3075
 
                    new in (_mod_branch.BzrBranchFormat7,
3076
 
                            _mod_branch.BzrBranchFormat8)):
 
2701
                    new == _mod_branch.BzrBranchFormat7):
3077
2702
                    branch_converter = _mod_branch.Converter6to7()
3078
 
                elif (old == _mod_branch.BzrBranchFormat7 and
3079
 
                      new is _mod_branch.BzrBranchFormat8):
3080
 
                    branch_converter = _mod_branch.Converter7to8()
3081
2703
                else:
3082
 
                    raise errors.BadConversionTarget("No converter", new,
3083
 
                        branch._format)
 
2704
                    raise errors.BadConversionTarget("No converter", new)
3084
2705
                branch_converter.convert(branch)
3085
2706
                branch = self.bzrdir.open_branch()
3086
2707
                old = branch._format.__class__
3101
2722
                isinstance(self.target_format.workingtree_format,
3102
2723
                    workingtree_4.WorkingTreeFormat5)):
3103
2724
                workingtree_4.Converter4to5().convert(tree)
3104
 
            if (isinstance(tree, workingtree_4.DirStateWorkingTree) and
3105
 
                not isinstance(tree, workingtree_4.WorkingTree6) and
3106
 
                isinstance(self.target_format.workingtree_format,
3107
 
                    workingtree_4.WorkingTreeFormat6)):
3108
 
                workingtree_4.Converter4or5to6().convert(tree)
3109
 
        self.pb.finished()
3110
2725
        return to_convert
3111
2726
 
3112
2727
 
3113
 
# This is not in remote.py because it's relatively small, and needs to be
3114
 
# registered. Putting it in remote.py creates a circular import problem.
 
2728
# This is not in remote.py because it's small, and needs to be registered.
 
2729
# Putting it in remote.py creates a circular import problem.
3115
2730
# we can make it a lazy object if the control formats is turned into something
3116
2731
# like a registry.
3117
2732
class RemoteBzrDirFormat(BzrDirMetaFormat1):
3119
2734
 
3120
2735
    def __init__(self):
3121
2736
        BzrDirMetaFormat1.__init__(self)
3122
 
        # XXX: It's a bit ugly that the network name is here, because we'd
3123
 
        # like to believe that format objects are stateless or at least
3124
 
        # immutable,  However, we do at least avoid mutating the name after
3125
 
        # it's returned.  See <https://bugs.edge.launchpad.net/bzr/+bug/504102>
3126
2737
        self._network_name = None
3127
2738
 
3128
 
    def __repr__(self):
3129
 
        return "%s(_network_name=%r)" % (self.__class__.__name__,
3130
 
            self._network_name)
3131
 
 
3132
2739
    def get_format_description(self):
3133
 
        if self._network_name:
3134
 
            real_format = network_format_registry.get(self._network_name)
3135
 
            return 'Remote: ' + real_format.get_format_description()
3136
2740
        return 'bzr remote bzrdir'
3137
2741
 
3138
2742
    def get_format_string(self):
3178
2782
            return local_dir_format.initialize_on_transport(transport)
3179
2783
        client = _SmartClient(client_medium)
3180
2784
        path = client.remote_path_from_transport(transport)
3181
 
        try:
3182
 
            response = client.call('BzrDirFormat.initialize', path)
3183
 
        except errors.ErrorFromSmartServer, err:
3184
 
            remote._translate_error(err, path=path)
 
2785
        response = client.call('BzrDirFormat.initialize', path)
3185
2786
        if response[0] != 'ok':
3186
2787
            raise errors.SmartProtocolError('unexpected response code %s' % (response,))
3187
2788
        format = RemoteBzrDirFormat()
3188
2789
        self._supply_sub_formats_to(format)
3189
2790
        return remote.RemoteBzrDir(transport, format)
3190
2791
 
3191
 
    def parse_NoneTrueFalse(self, arg):
3192
 
        if not arg:
3193
 
            return None
3194
 
        if arg == 'False':
3195
 
            return False
3196
 
        if arg == 'True':
3197
 
            return True
3198
 
        raise AssertionError("invalid arg %r" % arg)
3199
 
 
3200
 
    def _serialize_NoneTrueFalse(self, arg):
3201
 
        if arg is False:
3202
 
            return 'False'
3203
 
        if arg:
3204
 
            return 'True'
3205
 
        return ''
3206
 
 
3207
 
    def _serialize_NoneString(self, arg):
3208
 
        return arg or ''
3209
 
 
3210
 
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
3211
 
        create_prefix=False, force_new_repo=False, stacked_on=None,
3212
 
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
3213
 
        shared_repo=False):
3214
 
        try:
3215
 
            # hand off the request to the smart server
3216
 
            client_medium = transport.get_smart_medium()
3217
 
        except errors.NoSmartMedium:
3218
 
            do_vfs = True
3219
 
        else:
3220
 
            # Decline to open it if the server doesn't support our required
3221
 
            # version (3) so that the VFS-based transport will do it.
3222
 
            if client_medium.should_probe():
3223
 
                try:
3224
 
                    server_version = client_medium.protocol_version()
3225
 
                    if server_version != '2':
3226
 
                        do_vfs = True
3227
 
                    else:
3228
 
                        do_vfs = False
3229
 
                except errors.SmartProtocolError:
3230
 
                    # Apparently there's no usable smart server there, even though
3231
 
                    # the medium supports the smart protocol.
3232
 
                    do_vfs = True
3233
 
            else:
3234
 
                do_vfs = False
3235
 
        if not do_vfs:
3236
 
            client = _SmartClient(client_medium)
3237
 
            path = client.remote_path_from_transport(transport)
3238
 
            if client_medium._is_remote_before((1, 16)):
3239
 
                do_vfs = True
3240
 
        if do_vfs:
3241
 
            # TODO: lookup the local format from a server hint.
3242
 
            local_dir_format = BzrDirMetaFormat1()
3243
 
            self._supply_sub_formats_to(local_dir_format)
3244
 
            return local_dir_format.initialize_on_transport_ex(transport,
3245
 
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
3246
 
                force_new_repo=force_new_repo, stacked_on=stacked_on,
3247
 
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
3248
 
                make_working_trees=make_working_trees, shared_repo=shared_repo,
3249
 
                vfs_only=True)
3250
 
        return self._initialize_on_transport_ex_rpc(client, path, transport,
3251
 
            use_existing_dir, create_prefix, force_new_repo, stacked_on,
3252
 
            stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
3253
 
 
3254
 
    def _initialize_on_transport_ex_rpc(self, client, path, transport,
3255
 
        use_existing_dir, create_prefix, force_new_repo, stacked_on,
3256
 
        stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
3257
 
        args = []
3258
 
        args.append(self._serialize_NoneTrueFalse(use_existing_dir))
3259
 
        args.append(self._serialize_NoneTrueFalse(create_prefix))
3260
 
        args.append(self._serialize_NoneTrueFalse(force_new_repo))
3261
 
        args.append(self._serialize_NoneString(stacked_on))
3262
 
        # stack_on_pwd is often/usually our transport
3263
 
        if stack_on_pwd:
3264
 
            try:
3265
 
                stack_on_pwd = transport.relpath(stack_on_pwd)
3266
 
                if not stack_on_pwd:
3267
 
                    stack_on_pwd = '.'
3268
 
            except errors.PathNotChild:
3269
 
                pass
3270
 
        args.append(self._serialize_NoneString(stack_on_pwd))
3271
 
        args.append(self._serialize_NoneString(repo_format_name))
3272
 
        args.append(self._serialize_NoneTrueFalse(make_working_trees))
3273
 
        args.append(self._serialize_NoneTrueFalse(shared_repo))
3274
 
        request_network_name = self._network_name or \
3275
 
            BzrDirFormat.get_default_format().network_name()
3276
 
        try:
3277
 
            response = client.call('BzrDirFormat.initialize_ex_1.16',
3278
 
                request_network_name, path, *args)
3279
 
        except errors.UnknownSmartMethod:
3280
 
            client._medium._remember_remote_is_before((1,16))
3281
 
            local_dir_format = BzrDirMetaFormat1()
3282
 
            self._supply_sub_formats_to(local_dir_format)
3283
 
            return local_dir_format.initialize_on_transport_ex(transport,
3284
 
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
3285
 
                force_new_repo=force_new_repo, stacked_on=stacked_on,
3286
 
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
3287
 
                make_working_trees=make_working_trees, shared_repo=shared_repo,
3288
 
                vfs_only=True)
3289
 
        except errors.ErrorFromSmartServer, err:
3290
 
            remote._translate_error(err, path=path)
3291
 
        repo_path = response[0]
3292
 
        bzrdir_name = response[6]
3293
 
        require_stacking = response[7]
3294
 
        require_stacking = self.parse_NoneTrueFalse(require_stacking)
3295
 
        format = RemoteBzrDirFormat()
3296
 
        format._network_name = bzrdir_name
3297
 
        self._supply_sub_formats_to(format)
3298
 
        bzrdir = remote.RemoteBzrDir(transport, format, _client=client)
3299
 
        if repo_path:
3300
 
            repo_format = remote.response_tuple_to_repo_format(response[1:])
3301
 
            if repo_path == '.':
3302
 
                repo_path = ''
3303
 
            if repo_path:
3304
 
                repo_bzrdir_format = RemoteBzrDirFormat()
3305
 
                repo_bzrdir_format._network_name = response[5]
3306
 
                repo_bzr = remote.RemoteBzrDir(transport.clone(repo_path),
3307
 
                    repo_bzrdir_format)
3308
 
            else:
3309
 
                repo_bzr = bzrdir
3310
 
            final_stack = response[8] or None
3311
 
            final_stack_pwd = response[9] or None
3312
 
            if final_stack_pwd:
3313
 
                final_stack_pwd = urlutils.join(
3314
 
                    transport.base, final_stack_pwd)
3315
 
            remote_repo = remote.RemoteRepository(repo_bzr, repo_format)
3316
 
            if len(response) > 10:
3317
 
                # Updated server verb that locks remotely.
3318
 
                repo_lock_token = response[10] or None
3319
 
                remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
3320
 
                if repo_lock_token:
3321
 
                    remote_repo.dont_leave_lock_in_place()
3322
 
            else:
3323
 
                remote_repo.lock_write()
3324
 
            policy = UseExistingRepository(remote_repo, final_stack,
3325
 
                final_stack_pwd, require_stacking)
3326
 
            policy.acquire_repository()
3327
 
        else:
3328
 
            remote_repo = None
3329
 
            policy = None
3330
 
        bzrdir._format.set_branch_format(self.get_branch_format())
3331
 
        if require_stacking:
3332
 
            # The repo has already been created, but we need to make sure that
3333
 
            # we'll make a stackable branch.
3334
 
            bzrdir._format.require_stacking(_skip_repo=True)
3335
 
        return remote_repo, bzrdir, require_stacking, policy
3336
 
 
3337
2792
    def _open(self, transport):
3338
2793
        return remote.RemoteBzrDir(transport, self)
3339
2794
 
3346
2801
        # Always return a RemoteRepositoryFormat object, but if a specific bzr
3347
2802
        # repository format has been asked for, tell the RemoteRepositoryFormat
3348
2803
        # that it should use that for init() etc.
3349
 
        result = remote.RemoteRepositoryFormat()
 
2804
        result =  remote.RemoteRepositoryFormat()
3350
2805
        custom_format = getattr(self, '_repository_format', None)
3351
2806
        if custom_format:
 
2807
            # We will use the custom format to create repositories over the
 
2808
            # wire; expose its details like rich_root_data for code to query
3352
2809
            if isinstance(custom_format, remote.RemoteRepositoryFormat):
3353
 
                return custom_format
 
2810
                result._custom_format = custom_format._custom_format
3354
2811
            else:
3355
 
                # We will use the custom format to create repositories over the
3356
 
                # wire; expose its details like rich_root_data for code to
3357
 
                # query
3358
2812
                result._custom_format = custom_format
 
2813
            result.rich_root_data = custom_format.rich_root_data
3359
2814
        return result
3360
2815
 
3361
2816
    def get_branch_format(self):
3513
2968
            if info.native:
3514
2969
                help = '(native) ' + help
3515
2970
            return ':%s:\n%s\n\n' % (key,
3516
 
                textwrap.fill(help, initial_indent='    ',
3517
 
                    subsequent_indent='    ',
3518
 
                    break_long_words=False))
 
2971
                    textwrap.fill(help, initial_indent='    ',
 
2972
                    subsequent_indent='    '))
3519
2973
        if default_realkey is not None:
3520
2974
            output += wrapped(default_realkey, '(default) %s' % default_help,
3521
2975
                              self.get_info('default'))
3531
2985
                experimental_pairs.append((key, help))
3532
2986
            else:
3533
2987
                output += wrapped(key, help, info)
3534
 
        output += "\nSee :doc:`formats-help` for more about storage formats."
 
2988
        output += "\nSee ``bzr help formats`` for more about storage formats."
3535
2989
        other_output = ""
3536
2990
        if len(experimental_pairs) > 0:
3537
2991
            other_output += "Experimental formats are shown below.\n\n"
3550
3004
            other_output += \
3551
3005
                "\nNo deprecated formats are available.\n\n"
3552
3006
        other_output += \
3553
 
                "\nSee :doc:`formats-help` for more about storage formats."
 
3007
            "\nSee ``bzr help formats`` for more about storage formats."
3554
3008
 
3555
3009
        if topic == 'other-formats':
3556
3010
            return other_output
3595
3049
                stack_on = self._get_full_stack_on()
3596
3050
        try:
3597
3051
            branch.set_stacked_on_url(stack_on)
3598
 
        except (errors.UnstackableBranchFormat,
3599
 
                errors.UnstackableRepositoryFormat):
 
3052
        except errors.UnstackableBranchFormat:
3600
3053
            if self._require_stacking:
3601
3054
                raise
3602
3055
 
3603
 
    def requires_stacking(self):
3604
 
        """Return True if this policy requires stacking."""
3605
 
        return self._stack_on is not None and self._require_stacking
3606
 
 
3607
3056
    def _get_full_stack_on(self):
3608
3057
        """Get a fully-qualified URL for the stack_on location."""
3609
3058
        if self._stack_on is None:
3618
3067
        stack_on = self._get_full_stack_on()
3619
3068
        if stack_on is None:
3620
3069
            return
3621
 
        try:
3622
 
            stacked_dir = BzrDir.open(stack_on,
3623
 
                                      possible_transports=possible_transports)
3624
 
        except errors.JailBreak:
3625
 
            # We keep the stacking details, but we are in the server code so
3626
 
            # actually stacking is not needed.
3627
 
            return
 
3070
        stacked_dir = BzrDir.open(stack_on,
 
3071
                                  possible_transports=possible_transports)
3628
3072
        try:
3629
3073
            stacked_repo = stacked_dir.open_branch().repository
3630
3074
        except errors.NotBranchError:
3645
3089
        :param make_working_trees: If creating a repository, set
3646
3090
            make_working_trees to this value (if non-None)
3647
3091
        :param shared: If creating a repository, make it shared if True
3648
 
        :return: A repository, is_new_flag (True if the repository was
3649
 
            created).
 
3092
        :return: A repository
3650
3093
        """
3651
3094
        raise NotImplemented(RepositoryAcquisitionPolicy.acquire_repository)
3652
3095
 
3672
3115
 
3673
3116
        Creates the desired repository in the bzrdir we already have.
3674
3117
        """
3675
 
        stack_on = self._get_full_stack_on()
3676
 
        if stack_on:
3677
 
            format = self._bzrdir._format
3678
 
            format.require_stacking(stack_on=stack_on,
3679
 
                                    possible_transports=[self._bzrdir.root_transport])
3680
 
            if not self._require_stacking:
3681
 
                # We have picked up automatic stacking somewhere.
3682
 
                note('Using default stacking branch %s at %s', self._stack_on,
3683
 
                    self._stack_on_pwd)
3684
3118
        repository = self._bzrdir.create_repository(shared=shared)
3685
3119
        self._add_fallback(repository,
3686
3120
                           possible_transports=[self._bzrdir.transport])
3687
3121
        if make_working_trees is not None:
3688
3122
            repository.set_make_working_trees(make_working_trees)
3689
 
        return repository, True
 
3123
        return repository
3690
3124
 
3691
3125
 
3692
3126
class UseExistingRepository(RepositoryAcquisitionPolicy):
3708
3142
    def acquire_repository(self, make_working_trees=None, shared=False):
3709
3143
        """Implementation of RepositoryAcquisitionPolicy.acquire_repository
3710
3144
 
3711
 
        Returns an existing repository to use.
 
3145
        Returns an existing repository to use
3712
3146
        """
3713
3147
        self._add_fallback(self._repository,
3714
3148
                       possible_transports=[self._repository.bzrdir.transport])
3715
 
        return self._repository, False
 
3149
        return self._repository
3716
3150
 
3717
3151
 
3718
3152
# Please register new formats after old formats so that formats
3725
3159
format_registry.register('weave', BzrDirFormat6,
3726
3160
    'Pre-0.8 format.  Slower than knit and does not'
3727
3161
    ' support checkouts or shared repositories.',
3728
 
    hidden=True,
3729
3162
    deprecated=True)
3730
3163
format_registry.register_metadir('metaweave',
3731
3164
    'bzrlib.repofmt.weaverepo.RepositoryFormat7',
3732
3165
    'Transitional format in 0.8.  Slower than knit.',
3733
3166
    branch_format='bzrlib.branch.BzrBranchFormat5',
3734
3167
    tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3735
 
    hidden=True,
3736
3168
    deprecated=True)
3737
3169
format_registry.register_metadir('knit',
3738
3170
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3739
3171
    'Format using knits.  Recommended for interoperation with bzr <= 0.14.',
3740
3172
    branch_format='bzrlib.branch.BzrBranchFormat5',
3741
3173
    tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3742
 
    hidden=True,
3743
3174
    deprecated=True)
3744
3175
format_registry.register_metadir('dirstate',
3745
3176
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3749
3180
    # this uses bzrlib.workingtree.WorkingTreeFormat4 because importing
3750
3181
    # directly from workingtree_4 triggers a circular import.
3751
3182
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3752
 
    hidden=True,
3753
3183
    deprecated=True)
3754
3184
format_registry.register_metadir('dirstate-tags',
3755
3185
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3758
3188
        ' Incompatible with bzr < 0.15.',
3759
3189
    branch_format='bzrlib.branch.BzrBranchFormat6',
3760
3190
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3761
 
    hidden=True,
3762
3191
    deprecated=True)
3763
3192
format_registry.register_metadir('rich-root',
3764
3193
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit4',
3766
3195
        ' bzr < 1.0.',
3767
3196
    branch_format='bzrlib.branch.BzrBranchFormat6',
3768
3197
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3769
 
    hidden=True,
3770
3198
    deprecated=True)
3771
3199
format_registry.register_metadir('dirstate-with-subtree',
3772
3200
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
3783
3211
    help='New in 0.92: Pack-based format with data compatible with '
3784
3212
        'dirstate-tags format repositories. Interoperates with '
3785
3213
        'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3786
 
        ,
 
3214
        'Previously called knitpack-experimental.  '
 
3215
        'For more information, see '
 
3216
        'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
3787
3217
    branch_format='bzrlib.branch.BzrBranchFormat6',
3788
3218
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3789
3219
    )
3792
3222
    help='New in 0.92: Pack-based format with data compatible with '
3793
3223
        'dirstate-with-subtree format repositories. Interoperates with '
3794
3224
        'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3795
 
        ,
 
3225
        'Previously called knitpack-experimental.  '
 
3226
        'For more information, see '
 
3227
        'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
3796
3228
    branch_format='bzrlib.branch.BzrBranchFormat6',
3797
3229
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3798
3230
    hidden=True,
3801
3233
format_registry.register_metadir('rich-root-pack',
3802
3234
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack4',
3803
3235
    help='New in 1.0: A variant of pack-0.92 that supports rich-root data '
3804
 
         '(needed for bzr-svn and bzr-git).',
 
3236
         '(needed for bzr-svn).',
3805
3237
    branch_format='bzrlib.branch.BzrBranchFormat6',
3806
3238
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3807
 
    hidden=True,
3808
3239
    )
3809
3240
format_registry.register_metadir('1.6',
3810
3241
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5',
3813
3244
         'not present locally.',
3814
3245
    branch_format='bzrlib.branch.BzrBranchFormat7',
3815
3246
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3816
 
    hidden=True,
3817
3247
    )
3818
3248
format_registry.register_metadir('1.6.1-rich-root',
3819
3249
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5RichRoot',
3820
3250
    help='A variant of 1.6 that supports rich-root data '
3821
 
         '(needed for bzr-svn and bzr-git).',
 
3251
         '(needed for bzr-svn).',
3822
3252
    branch_format='bzrlib.branch.BzrBranchFormat7',
3823
3253
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3824
 
    hidden=True,
3825
3254
    )
3826
3255
format_registry.register_metadir('1.9',
3827
3256
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3830
3259
         'performance for most operations.',
3831
3260
    branch_format='bzrlib.branch.BzrBranchFormat7',
3832
3261
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3833
 
    hidden=True,
3834
3262
    )
3835
3263
format_registry.register_metadir('1.9-rich-root',
3836
3264
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3837
3265
    help='A variant of 1.9 that supports rich-root data '
3838
 
         '(needed for bzr-svn and bzr-git).',
 
3266
         '(needed for bzr-svn).',
3839
3267
    branch_format='bzrlib.branch.BzrBranchFormat7',
3840
3268
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3841
 
    hidden=True,
3842
3269
    )
3843
 
format_registry.register_metadir('1.14',
 
3270
format_registry.register_metadir('development-wt5',
3844
3271
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3845
 
    help='A working-tree format that supports content filtering.',
 
3272
    help='A working-tree format that supports views and content filtering.',
3846
3273
    branch_format='bzrlib.branch.BzrBranchFormat7',
3847
3274
    tree_format='bzrlib.workingtree.WorkingTreeFormat5',
 
3275
    experimental=True,
3848
3276
    )
3849
 
format_registry.register_metadir('1.14-rich-root',
 
3277
format_registry.register_metadir('development-wt5-rich-root',
3850
3278
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3851
 
    help='A variant of 1.14 that supports rich-root data '
3852
 
         '(needed for bzr-svn and bzr-git).',
 
3279
    help='A variant of development-wt5 that supports rich-root data '
 
3280
         '(needed for bzr-svn).',
3853
3281
    branch_format='bzrlib.branch.BzrBranchFormat7',
3854
3282
    tree_format='bzrlib.workingtree.WorkingTreeFormat5',
 
3283
    experimental=True,
3855
3284
    )
3856
 
# The following un-numbered 'development' formats should always just be aliases.
3857
 
format_registry.register_metadir('development-rich-root',
3858
 
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK1',
3859
 
    help='Current development format. Supports rich roots. Can convert data '
3860
 
        'to and from rich-root-pack (and anything compatible with '
3861
 
        'rich-root-pack) format repositories. Repositories and branches in '
3862
 
        'this format can only be read by bzr.dev. Please read '
3863
 
        'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
 
3285
# The following two formats should always just be aliases.
 
3286
format_registry.register_metadir('development',
 
3287
    'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2',
 
3288
    help='Current development format. Can convert data to and from pack-0.92 '
 
3289
        '(and anything compatible with pack-0.92) format repositories. '
 
3290
        'Repositories and branches in this format can only be read by bzr.dev. '
 
3291
        'Please read '
 
3292
        'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3864
3293
        'before use.',
3865
3294
    branch_format='bzrlib.branch.BzrBranchFormat7',
3866
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
 
3295
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3867
3296
    experimental=True,
3868
3297
    alias=True,
3869
 
    hidden=True,
3870
3298
    )
3871
3299
format_registry.register_metadir('development-subtree',
3872
3300
    'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
3874
3302
        'from pack-0.92-subtree (and anything compatible with '
3875
3303
        'pack-0.92-subtree) format repositories. Repositories and branches in '
3876
3304
        'this format can only be read by bzr.dev. Please read '
3877
 
        'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
 
3305
        'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3878
3306
        'before use.',
3879
3307
    branch_format='bzrlib.branch.BzrBranchFormat7',
3880
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
 
3308
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3881
3309
    experimental=True,
3882
 
    hidden=True,
3883
 
    alias=False, # Restore to being an alias when an actual development subtree format is added
3884
 
                 # This current non-alias status is simply because we did not introduce a
3885
 
                 # chk based subtree format.
 
3310
    alias=True,
3886
3311
    )
3887
 
 
3888
3312
# And the development formats above will have aliased one of the following:
3889
 
format_registry.register_metadir('development6-rich-root',
3890
 
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK1',
3891
 
    help='pack-1.9 with 255-way hashed CHK inv, group compress, rich roots '
3892
 
        'Please read '
3893
 
        'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3894
 
        'before use.',
3895
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3896
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3897
 
    hidden=True,
3898
 
    experimental=True,
3899
 
    )
3900
 
 
3901
 
format_registry.register_metadir('development7-rich-root',
3902
 
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK2',
3903
 
    help='pack-1.9 with 255-way hashed CHK inv, bencode revision, group compress, '
3904
 
        'rich roots. Please read '
3905
 
        'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3906
 
        'before use.',
3907
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3908
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3909
 
    hidden=True,
3910
 
    experimental=True,
3911
 
    )
3912
 
 
3913
 
format_registry.register_metadir('2a',
3914
 
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
3915
 
    help='First format for bzr 2.0 series.\n'
3916
 
        'Uses group-compress storage.\n'
3917
 
        'Provides rich roots which are a one-way transition.\n',
3918
 
        # 'storage in packs, 255-way hashed CHK inventory, bencode revision, group compress, '
3919
 
        # 'rich roots. Supported by bzr 1.16 and later.',
3920
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3921
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3922
 
    experimental=True,
3923
 
    )
3924
 
 
3925
 
# The following format should be an alias for the rich root equivalent 
3926
 
# of the default format
3927
 
format_registry.register_metadir('default-rich-root',
3928
 
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
3929
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3930
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3931
 
    alias=True,
3932
 
    hidden=True,
3933
 
    help='Same as 2a.')
3934
 
 
 
3313
format_registry.register_metadir('development2',
 
3314
    'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2',
 
3315
    help='1.6.1 with B+Tree based index. '
 
3316
        'Please read '
 
3317
        'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
 
3318
        'before use.',
 
3319
    branch_format='bzrlib.branch.BzrBranchFormat7',
 
3320
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
 
3321
    hidden=True,
 
3322
    experimental=True,
 
3323
    )
 
3324
format_registry.register_metadir('development2-subtree',
 
3325
    'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
 
3326
    help='1.6.1-subtree with B+Tree based index. '
 
3327
        'Please read '
 
3328
        'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
 
3329
        'before use.',
 
3330
    branch_format='bzrlib.branch.BzrBranchFormat7',
 
3331
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
 
3332
    hidden=True,
 
3333
    experimental=True,
 
3334
    )
3935
3335
# The current format that is made on 'bzr init'.
3936
 
format_registry.set_default('2a')
 
3336
format_registry.set_default('pack-0.92')