← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bzrdir.py

  • Committer: Sidnei da Silva
  • Date: 2009-05-29 14:19:29 UTC
  • mto: (4531.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 4532.
  • Revision ID: sidnei.da.silva@canonical.com-20090529141929-3heywbvj36po72a5
- Add initial config

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bzrdir.py
1
 
# Copyright (C) 2006-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
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(), """
71
70
    do_catching_redirections,
72
71
    get_transport,
73
72
    local,
 
73
    remote as remote_transport,
74
74
    )
75
75
from bzrlib.weave import Weave
76
76
""")
78
78
from bzrlib.trace import (
79
79
    mutter,
80
80
    note,
81
 
    warning,
82
81
    )
83
82
 
84
83
from bzrlib import (
130
129
        return True
131
130
 
132
131
    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
132
        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
 
133
        source_repo_format = self._format.repository_format
 
134
        source_repo_format.check_conversion_target(target_repo_format)
143
135
 
144
136
    @staticmethod
145
137
    def _check_supported(format, allow_unsupported,
355
347
                for subdir in sorted(subdirs, reverse=True):
356
348
                    pending.append(current_transport.clone(subdir))
357
349
 
358
 
    def list_branches(self):
359
 
        """Return a sequence of all branches local to this control directory.
360
 
 
361
 
        """
362
 
        try:
363
 
            return [self.open_branch()]
364
 
        except errors.NotBranchError:
365
 
            return []
366
 
 
367
350
    @staticmethod
368
351
    def find_branches(transport):
369
352
        """Find all branches under a transport.
381
364
            except errors.NoRepositoryPresent:
382
365
                pass
383
366
            else:
384
 
                return False, ([], repository)
385
 
            return True, (bzrdir.list_branches(), None)
386
 
        ret = []
387
 
        for branches, repo in BzrDir.find_bzrdirs(transport,
388
 
                                                  evaluate=evaluate):
 
367
                return False, (None, repository)
 
368
            try:
 
369
                branch = bzrdir.open_branch()
 
370
            except errors.NotBranchError:
 
371
                return True, (None, None)
 
372
            else:
 
373
                return True, (branch, None)
 
374
        branches = []
 
375
        for branch, repo in BzrDir.find_bzrdirs(transport, evaluate=evaluate):
389
376
            if repo is not None:
390
 
                ret.extend(repo.find_branches())
391
 
            if branches is not None:
392
 
                ret.extend(branches)
393
 
        return ret
 
377
                branches.extend(repo.find_branches())
 
378
            if branch is not None:
 
379
                branches.append(branch)
 
380
        return branches
394
381
 
395
382
    def destroy_repository(self):
396
383
        """Destroy the repository in this BzrDir"""
590
577
            # permissions as the .bzr directory (probably a bug in copy_tree)
591
578
            old_path = self.root_transport.abspath('.bzr')
592
579
            new_path = self.root_transport.abspath('backup.bzr')
593
 
            ui.ui_factory.note('making backup of %s\n  to %s' % (old_path, new_path,))
 
580
            pb.note('making backup of %s' % (old_path,))
 
581
            pb.note('  to %s' % (new_path,))
594
582
            self.root_transport.copy_tree('.bzr', 'backup.bzr')
595
583
            return (old_path, new_path)
596
584
        finally:
1246
1234
        return result
1247
1235
 
1248
1236
    def push_branch(self, source, revision_id=None, overwrite=False, 
1249
 
        remember=False, create_prefix=False):
 
1237
        remember=False):
1250
1238
        """Push the source branch into this BzrDir."""
1251
1239
        br_to = None
1252
1240
        # If we can open a branch, use its direct repository, otherwise see
1397
1385
        # that can do wonky stuff here, and that only
1398
1386
        # happens for creating checkouts, which cannot be
1399
1387
        # done on this format anyway. So - acceptable wart.
1400
 
        if hardlink:
1401
 
            warning("can't support hardlinked working trees in %r"
1402
 
                % (self,))
1403
1388
        try:
1404
1389
            result = self.open_workingtree(recommend_upgrade=False)
1405
1390
        except errors.NoSuchFile:
1542
1527
    This is a deprecated format and may be removed after sept 2006.
1543
1528
    """
1544
1529
 
1545
 
    def has_workingtree(self):
1546
 
        """See BzrDir.has_workingtree."""
1547
 
        return True
1548
 
    
1549
1530
    def open_repository(self):
1550
1531
        """See BzrDir.open_repository."""
1551
1532
        from bzrlib.repofmt.weaverepo import RepositoryFormat5
1567
1548
    This is a deprecated format and may be removed after sept 2006.
1568
1549
    """
1569
1550
 
1570
 
    def has_workingtree(self):
1571
 
        """See BzrDir.has_workingtree."""
1572
 
        return True
1573
 
    
1574
1551
    def open_repository(self):
1575
1552
        """See BzrDir.open_repository."""
1576
1553
        from bzrlib.repofmt.weaverepo import RepositoryFormat6
1654
1631
 
1655
1632
    def get_branch_transport(self, branch_format):
1656
1633
        """See BzrDir.get_branch_transport()."""
1657
 
        # XXX: this shouldn't implicitly create the directory if it's just
1658
 
        # promising to get a transport -- mbp 20090727
1659
1634
        if branch_format is None:
1660
1635
            return self.transport.clone('branch')
1661
1636
        try:
1696
1671
            pass
1697
1672
        return self.transport.clone('checkout')
1698
1673
 
1699
 
    def has_workingtree(self):
1700
 
        """Tell if this bzrdir contains a working tree.
1701
 
 
1702
 
        This will still raise an exception if the bzrdir has a workingtree that
1703
 
        is remote & inaccessible.
1704
 
 
1705
 
        Note: if you're going to open the working tree, you should just go
1706
 
        ahead and try, and not ask permission first.
1707
 
        """
1708
 
        from bzrlib.workingtree import WorkingTreeFormat
1709
 
        try:
1710
 
            WorkingTreeFormat.find_format(self)
1711
 
        except errors.NoWorkingTree:
1712
 
            return False
1713
 
        return True
1714
 
 
1715
1674
    def needs_format_conversion(self, format=None):
1716
1675
        """See BzrDir.needs_format_conversion()."""
1717
1676
        if format is None:
1833
1792
    def probe_transport(klass, transport):
1834
1793
        """Return the .bzrdir style format present in a directory."""
1835
1794
        try:
1836
 
            format_string = transport.get_bytes(".bzr/branch-format")
 
1795
            format_string = transport.get(".bzr/branch-format").read()
1837
1796
        except errors.NoSuchFile:
1838
1797
            raise errors.NotBranchError(path=transport.base)
1839
1798
 
2399
2358
    def set_branch_format(self, format):
2400
2359
        self._branch_format = format
2401
2360
 
2402
 
    def require_stacking(self, stack_on=None, possible_transports=None,
2403
 
            _skip_repo=False):
2404
 
        """We have a request to stack, try to ensure the formats support it.
2405
 
 
2406
 
        :param stack_on: If supplied, it is the URL to a branch that we want to
2407
 
            stack on. Check to see if that format supports stacking before
2408
 
            forcing an upgrade.
2409
 
        """
2410
 
        # Stacking is desired. requested by the target, but does the place it
2411
 
        # points at support stacking? If it doesn't then we should
2412
 
        # not implicitly upgrade. We check this here.
2413
 
        new_repo_format = None
2414
 
        new_branch_format = None
2415
 
 
2416
 
        # a bit of state for get_target_branch so that we don't try to open it
2417
 
        # 2 times, for both repo *and* branch
2418
 
        target = [None, False, None] # target_branch, checked, upgrade anyway
2419
 
        def get_target_branch():
2420
 
            if target[1]:
2421
 
                # We've checked, don't check again
2422
 
                return target
2423
 
            if stack_on is None:
2424
 
                # No target format, that means we want to force upgrading
2425
 
                target[:] = [None, True, True]
2426
 
                return target
2427
 
            try:
2428
 
                target_dir = BzrDir.open(stack_on,
2429
 
                    possible_transports=possible_transports)
2430
 
            except errors.NotBranchError:
2431
 
                # Nothing there, don't change formats
2432
 
                target[:] = [None, True, False]
2433
 
                return target
2434
 
            except errors.JailBreak:
2435
 
                # JailBreak, JFDI and upgrade anyway
2436
 
                target[:] = [None, True, True]
2437
 
                return target
2438
 
            try:
2439
 
                target_branch = target_dir.open_branch()
2440
 
            except errors.NotBranchError:
2441
 
                # No branch, don't upgrade formats
2442
 
                target[:] = [None, True, False]
2443
 
                return target
2444
 
            target[:] = [target_branch, True, False]
2445
 
            return target
2446
 
 
2447
 
        if (not _skip_repo and
2448
 
                 not self.repository_format.supports_external_lookups):
2449
 
            # We need to upgrade the Repository.
2450
 
            target_branch, _, do_upgrade = get_target_branch()
2451
 
            if target_branch is None:
2452
 
                # We don't have a target branch, should we upgrade anyway?
2453
 
                if do_upgrade:
2454
 
                    # stack_on is inaccessible, JFDI.
2455
 
                    # TODO: bad monkey, hard-coded formats...
2456
 
                    if self.repository_format.rich_root_data:
2457
 
                        new_repo_format = pack_repo.RepositoryFormatKnitPack5RichRoot()
2458
 
                    else:
2459
 
                        new_repo_format = pack_repo.RepositoryFormatKnitPack5()
2460
 
            else:
2461
 
                # If the target already supports stacking, then we know the
2462
 
                # project is already able to use stacking, so auto-upgrade
2463
 
                # for them
2464
 
                new_repo_format = target_branch.repository._format
2465
 
                if not new_repo_format.supports_external_lookups:
2466
 
                    # target doesn't, source doesn't, so don't auto upgrade
2467
 
                    # repo
2468
 
                    new_repo_format = None
2469
 
            if new_repo_format is not None:
2470
 
                self.repository_format = new_repo_format
2471
 
                note('Source repository format does not support stacking,'
2472
 
                     ' using format:\n  %s',
2473
 
                     new_repo_format.get_format_description())
2474
 
 
 
2361
    def require_stacking(self):
2475
2362
        if not self.get_branch_format().supports_stacking():
2476
 
            # We just checked the repo, now lets check if we need to
2477
 
            # upgrade the branch format
2478
 
            target_branch, _, do_upgrade = get_target_branch()
2479
 
            if target_branch is None:
2480
 
                if do_upgrade:
2481
 
                    # TODO: bad monkey, hard-coded formats...
2482
 
                    new_branch_format = branch.BzrBranchFormat7()
 
2363
            # We need to make a stacked branch, but the default format for the
 
2364
            # target doesn't support stacking.  So force a branch that *can*
 
2365
            # support stacking.
 
2366
            from bzrlib.branch import BzrBranchFormat7
 
2367
            branch_format = BzrBranchFormat7()
 
2368
            self.set_branch_format(branch_format)
 
2369
            mutter("using %r for stacking" % (branch_format,))
 
2370
            from bzrlib.repofmt import pack_repo
 
2371
            if self.repository_format.rich_root_data:
 
2372
                bzrdir_format_name = '1.6.1-rich-root'
 
2373
                repo_format = pack_repo.RepositoryFormatKnitPack5RichRoot()
2483
2374
            else:
2484
 
                new_branch_format = target_branch._format
2485
 
                if not new_branch_format.supports_stacking():
2486
 
                    new_branch_format = None
2487
 
            if new_branch_format is not None:
2488
 
                # Does support stacking, use its format.
2489
 
                self.set_branch_format(new_branch_format)
2490
 
                note('Source branch format does not support stacking,'
2491
 
                     ' using format:\n  %s',
2492
 
                     new_branch_format.get_format_description())
 
2375
                bzrdir_format_name = '1.6'
 
2376
                repo_format = pack_repo.RepositoryFormatKnitPack5()
 
2377
            note('Source format does not support stacking, using format:'
 
2378
                 ' \'%s\'\n  %s\n',
 
2379
                 bzrdir_format_name, repo_format.get_format_description())
 
2380
            self.repository_format = repo_format
2493
2381
 
2494
2382
    def get_converter(self, format=None):
2495
2383
        """See BzrDirFormat.get_converter()."""
2615
2503
    def convert(self, to_convert, pb):
2616
2504
        """See Converter.convert()."""
2617
2505
        self.bzrdir = to_convert
2618
 
        if pb is not None:
2619
 
            warnings.warn("pb parameter to convert() is deprecated")
2620
 
        self.pb = ui.ui_factory.nested_progress_bar()
2621
 
        try:
2622
 
            ui.ui_factory.note('starting upgrade from format 4 to 5')
2623
 
            if isinstance(self.bzrdir.transport, local.LocalTransport):
2624
 
                self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
2625
 
            self._convert_to_weaves()
2626
 
            return BzrDir.open(self.bzrdir.root_transport.base)
2627
 
        finally:
2628
 
            self.pb.finished()
 
2506
        self.pb = pb
 
2507
        self.pb.note('starting upgrade from format 4 to 5')
 
2508
        if isinstance(self.bzrdir.transport, local.LocalTransport):
 
2509
            self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
 
2510
        self._convert_to_weaves()
 
2511
        return BzrDir.open(self.bzrdir.root_transport.base)
2629
2512
 
2630
2513
    def _convert_to_weaves(self):
2631
 
        ui.ui_factory.note('note: upgrade may be faster if all store files are ungzipped first')
 
2514
        self.pb.note('note: upgrade may be faster if all store files are ungzipped first')
2632
2515
        try:
2633
2516
            # TODO permissions
2634
2517
            stat = self.bzrdir.transport.stat('weaves')
2662
2545
        self.pb.clear()
2663
2546
        self._write_all_weaves()
2664
2547
        self._write_all_revs()
2665
 
        ui.ui_factory.note('upgraded to weaves:')
2666
 
        ui.ui_factory.note('  %6d revisions and inventories' % len(self.revisions))
2667
 
        ui.ui_factory.note('  %6d revisions not present' % len(self.absent_revisions))
2668
 
        ui.ui_factory.note('  %6d texts' % self.text_count)
 
2548
        self.pb.note('upgraded to weaves:')
 
2549
        self.pb.note('  %6d revisions and inventories', len(self.revisions))
 
2550
        self.pb.note('  %6d revisions not present', len(self.absent_revisions))
 
2551
        self.pb.note('  %6d texts', self.text_count)
2669
2552
        self._cleanup_spare_files_after_format4()
2670
2553
        self.branch._transport.put_bytes(
2671
2554
            'branch-format',
2739
2622
                       len(self.known_revisions))
2740
2623
        if not self.branch.repository.has_revision(rev_id):
2741
2624
            self.pb.clear()
2742
 
            ui.ui_factory.note('revision {%s} not present in branch; '
2743
 
                         'will be converted as a ghost' %
 
2625
            self.pb.note('revision {%s} not present in branch; '
 
2626
                         'will be converted as a ghost',
2744
2627
                         rev_id)
2745
2628
            self.absent_revisions.add(rev_id)
2746
2629
        else:
2816
2699
        del ie.text_id
2817
2700
 
2818
2701
    def get_parent_map(self, revision_ids):
2819
 
        """See graph.StackedParentsProvider.get_parent_map"""
 
2702
        """See graph._StackedParentsProvider.get_parent_map"""
2820
2703
        return dict((revision_id, self.revisions[revision_id])
2821
2704
                    for revision_id in revision_ids
2822
2705
                     if revision_id in self.revisions)
2872
2755
    def convert(self, to_convert, pb):
2873
2756
        """See Converter.convert()."""
2874
2757
        self.bzrdir = to_convert
2875
 
        pb = ui.ui_factory.nested_progress_bar()
2876
 
        try:
2877
 
            ui.ui_factory.note('starting upgrade from format 5 to 6')
2878
 
            self._convert_to_prefixed()
2879
 
            return BzrDir.open(self.bzrdir.root_transport.base)
2880
 
        finally:
2881
 
            pb.finished()
 
2758
        self.pb = pb
 
2759
        self.pb.note('starting upgrade from format 5 to 6')
 
2760
        self._convert_to_prefixed()
 
2761
        return BzrDir.open(self.bzrdir.root_transport.base)
2882
2762
 
2883
2763
    def _convert_to_prefixed(self):
2884
2764
        from bzrlib.store import TransportStore
2885
2765
        self.bzrdir.transport.delete('branch-format')
2886
2766
        for store_name in ["weaves", "revision-store"]:
2887
 
            ui.ui_factory.note("adding prefixes to %s" % store_name)
 
2767
            self.pb.note("adding prefixes to %s" % store_name)
2888
2768
            store_transport = self.bzrdir.transport.clone(store_name)
2889
2769
            store = TransportStore(store_transport, prefixed=True)
2890
2770
            for urlfilename in store_transport.list_dir('.'):
2917
2797
        from bzrlib.repofmt.weaverepo import RepositoryFormat7
2918
2798
        from bzrlib.branch import BzrBranchFormat5
2919
2799
        self.bzrdir = to_convert
2920
 
        self.pb = ui.ui_factory.nested_progress_bar()
 
2800
        self.pb = pb
2921
2801
        self.count = 0
2922
2802
        self.total = 20 # the steps we know about
2923
2803
        self.garbage_inventories = []
2924
2804
        self.dir_mode = self.bzrdir._get_dir_mode()
2925
2805
        self.file_mode = self.bzrdir._get_file_mode()
2926
2806
 
2927
 
        ui.ui_factory.note('starting upgrade from format 6 to metadir')
 
2807
        self.pb.note('starting upgrade from format 6 to metadir')
2928
2808
        self.bzrdir.transport.put_bytes(
2929
2809
                'branch-format',
2930
2810
                "Converting to format 6",
2980
2860
        else:
2981
2861
            has_checkout = True
2982
2862
        if not has_checkout:
2983
 
            ui.ui_factory.note('No working tree.')
 
2863
            self.pb.note('No working tree.')
2984
2864
            # If some checkout files are there, we may as well get rid of them.
2985
2865
            for name, mandatory in checkout_files:
2986
2866
                if name in bzrcontents:
3003
2883
            'branch-format',
3004
2884
            BzrDirMetaFormat1().get_format_string(),
3005
2885
            mode=self.file_mode)
3006
 
        self.pb.finished()
3007
2886
        return BzrDir.open(self.bzrdir.root_transport.base)
3008
2887
 
3009
2888
    def make_lock(self, name):
3045
2924
    def convert(self, to_convert, pb):
3046
2925
        """See Converter.convert()."""
3047
2926
        self.bzrdir = to_convert
3048
 
        self.pb = ui.ui_factory.nested_progress_bar()
 
2927
        self.pb = pb
3049
2928
        self.count = 0
3050
2929
        self.total = 1
3051
2930
        self.step('checking repository format')
3056
2935
        else:
3057
2936
            if not isinstance(repo._format, self.target_format.repository_format.__class__):
3058
2937
                from bzrlib.repository import CopyConverter
3059
 
                ui.ui_factory.note('starting repository conversion')
 
2938
                self.pb.note('starting repository conversion')
3060
2939
                converter = CopyConverter(self.target_format.repository_format)
3061
2940
                converter.convert(repo, pb)
3062
 
        for branch in self.bzrdir.list_branches():
 
2941
        try:
 
2942
            branch = self.bzrdir.open_branch()
 
2943
        except errors.NotBranchError:
 
2944
            pass
 
2945
        else:
3063
2946
            # TODO: conversions of Branch and Tree should be done by
3064
2947
            # InterXFormat lookups/some sort of registry.
3065
2948
            # Avoid circular imports
3080
2963
                      new is _mod_branch.BzrBranchFormat8):
3081
2964
                    branch_converter = _mod_branch.Converter7to8()
3082
2965
                else:
3083
 
                    raise errors.BadConversionTarget("No converter", new,
3084
 
                        branch._format)
 
2966
                    raise errors.BadConversionTarget("No converter", new)
3085
2967
                branch_converter.convert(branch)
3086
2968
                branch = self.bzrdir.open_branch()
3087
2969
                old = branch._format.__class__
3107
2989
                isinstance(self.target_format.workingtree_format,
3108
2990
                    workingtree_4.WorkingTreeFormat6)):
3109
2991
                workingtree_4.Converter4or5to6().convert(tree)
3110
 
        self.pb.finished()
3111
2992
        return to_convert
3112
2993
 
3113
2994
 
3120
3001
 
3121
3002
    def __init__(self):
3122
3003
        BzrDirMetaFormat1.__init__(self)
3123
 
        # XXX: It's a bit ugly that the network name is here, because we'd
3124
 
        # like to believe that format objects are stateless or at least
3125
 
        # immutable,  However, we do at least avoid mutating the name after
3126
 
        # it's returned.  See <https://bugs.edge.launchpad.net/bzr/+bug/504102>
3127
3004
        self._network_name = None
3128
3005
 
3129
 
    def __repr__(self):
3130
 
        return "%s(_network_name=%r)" % (self.__class__.__name__,
3131
 
            self._network_name)
3132
 
 
3133
3006
    def get_format_description(self):
3134
 
        if self._network_name:
3135
 
            real_format = network_format_registry.get(self._network_name)
3136
 
            return 'Remote: ' + real_format.get_format_description()
3137
3007
        return 'bzr remote bzrdir'
3138
3008
 
3139
3009
    def get_format_string(self):
3179
3049
            return local_dir_format.initialize_on_transport(transport)
3180
3050
        client = _SmartClient(client_medium)
3181
3051
        path = client.remote_path_from_transport(transport)
3182
 
        try:
3183
 
            response = client.call('BzrDirFormat.initialize', path)
3184
 
        except errors.ErrorFromSmartServer, err:
3185
 
            remote._translate_error(err, path=path)
 
3052
        response = client.call('BzrDirFormat.initialize', path)
3186
3053
        if response[0] != 'ok':
3187
3054
            raise errors.SmartProtocolError('unexpected response code %s' % (response,))
3188
3055
        format = RemoteBzrDirFormat()
3236
3103
        if not do_vfs:
3237
3104
            client = _SmartClient(client_medium)
3238
3105
            path = client.remote_path_from_transport(transport)
3239
 
            if client_medium._is_remote_before((1, 16)):
 
3106
            if client_medium._is_remote_before((1, 15)):
3240
3107
                do_vfs = True
3241
3108
        if do_vfs:
3242
3109
            # TODO: lookup the local format from a server hint.
3248
3115
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
3249
3116
                make_working_trees=make_working_trees, shared_repo=shared_repo,
3250
3117
                vfs_only=True)
3251
 
        return self._initialize_on_transport_ex_rpc(client, path, transport,
3252
 
            use_existing_dir, create_prefix, force_new_repo, stacked_on,
3253
 
            stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
3254
 
 
3255
 
    def _initialize_on_transport_ex_rpc(self, client, path, transport,
3256
 
        use_existing_dir, create_prefix, force_new_repo, stacked_on,
3257
 
        stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
3258
3118
        args = []
3259
3119
        args.append(self._serialize_NoneTrueFalse(use_existing_dir))
3260
3120
        args.append(self._serialize_NoneTrueFalse(create_prefix))
3272
3132
        args.append(self._serialize_NoneString(repo_format_name))
3273
3133
        args.append(self._serialize_NoneTrueFalse(make_working_trees))
3274
3134
        args.append(self._serialize_NoneTrueFalse(shared_repo))
3275
 
        request_network_name = self._network_name or \
 
3135
        if self._network_name is None:
 
3136
            self._network_name = \
3276
3137
            BzrDirFormat.get_default_format().network_name()
3277
3138
        try:
3278
 
            response = client.call('BzrDirFormat.initialize_ex_1.16',
3279
 
                request_network_name, path, *args)
 
3139
            response = client.call('BzrDirFormat.initialize_ex',
 
3140
                self.network_name(), path, *args)
3280
3141
        except errors.UnknownSmartMethod:
3281
 
            client._medium._remember_remote_is_before((1,16))
3282
3142
            local_dir_format = BzrDirMetaFormat1()
3283
3143
            self._supply_sub_formats_to(local_dir_format)
3284
3144
            return local_dir_format.initialize_on_transport_ex(transport,
3287
3147
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
3288
3148
                make_working_trees=make_working_trees, shared_repo=shared_repo,
3289
3149
                vfs_only=True)
3290
 
        except errors.ErrorFromSmartServer, err:
3291
 
            remote._translate_error(err, path=path)
3292
3150
        repo_path = response[0]
3293
3151
        bzrdir_name = response[6]
3294
3152
        require_stacking = response[7]
3310
3168
                repo_bzr = bzrdir
3311
3169
            final_stack = response[8] or None
3312
3170
            final_stack_pwd = response[9] or None
3313
 
            if final_stack_pwd:
3314
 
                final_stack_pwd = urlutils.join(
3315
 
                    transport.base, final_stack_pwd)
3316
3171
            remote_repo = remote.RemoteRepository(repo_bzr, repo_format)
3317
3172
            if len(response) > 10:
3318
3173
                # Updated server verb that locks remotely.
3328
3183
        else:
3329
3184
            remote_repo = None
3330
3185
            policy = None
3331
 
        bzrdir._format.set_branch_format(self.get_branch_format())
3332
 
        if require_stacking:
3333
 
            # The repo has already been created, but we need to make sure that
3334
 
            # we'll make a stackable branch.
3335
 
            bzrdir._format.require_stacking(_skip_repo=True)
3336
3186
        return remote_repo, bzrdir, require_stacking, policy
3337
3187
 
3338
3188
    def _open(self, transport):
3514
3364
            if info.native:
3515
3365
                help = '(native) ' + help
3516
3366
            return ':%s:\n%s\n\n' % (key,
3517
 
                textwrap.fill(help, initial_indent='    ',
3518
 
                    subsequent_indent='    ',
3519
 
                    break_long_words=False))
 
3367
                    textwrap.fill(help, initial_indent='    ',
 
3368
                    subsequent_indent='    '))
3520
3369
        if default_realkey is not None:
3521
3370
            output += wrapped(default_realkey, '(default) %s' % default_help,
3522
3371
                              self.get_info('default'))
3532
3381
                experimental_pairs.append((key, help))
3533
3382
            else:
3534
3383
                output += wrapped(key, help, info)
3535
 
        output += "\nSee :doc:`formats-help` for more about storage formats."
 
3384
        output += "\nSee ``bzr help formats`` for more about storage formats."
3536
3385
        other_output = ""
3537
3386
        if len(experimental_pairs) > 0:
3538
3387
            other_output += "Experimental formats are shown below.\n\n"
3551
3400
            other_output += \
3552
3401
                "\nNo deprecated formats are available.\n\n"
3553
3402
        other_output += \
3554
 
                "\nSee :doc:`formats-help` for more about storage formats."
 
3403
            "\nSee ``bzr help formats`` for more about storage formats."
3555
3404
 
3556
3405
        if topic == 'other-formats':
3557
3406
            return other_output
3601
3450
            if self._require_stacking:
3602
3451
                raise
3603
3452
 
3604
 
    def requires_stacking(self):
3605
 
        """Return True if this policy requires stacking."""
3606
 
        return self._stack_on is not None and self._require_stacking
3607
 
 
3608
3453
    def _get_full_stack_on(self):
3609
3454
        """Get a fully-qualified URL for the stack_on location."""
3610
3455
        if self._stack_on is None:
3675
3520
        """
3676
3521
        stack_on = self._get_full_stack_on()
3677
3522
        if stack_on:
 
3523
            # Stacking is desired. requested by the target, but does the place it
 
3524
            # points at support stacking? If it doesn't then we should
 
3525
            # not implicitly upgrade. We check this here.
3678
3526
            format = self._bzrdir._format
3679
 
            format.require_stacking(stack_on=stack_on,
3680
 
                                    possible_transports=[self._bzrdir.root_transport])
 
3527
            if not (format.repository_format.supports_external_lookups
 
3528
                and format.get_branch_format().supports_stacking()):
 
3529
                # May need to upgrade - but only do if the target also
 
3530
                # supports stacking. Note that this currently wastes
 
3531
                # network round trips to check - but we only do this
 
3532
                # when the source can't stack so it will fade away
 
3533
                # as people do upgrade.
 
3534
                branch_format = None
 
3535
                repo_format = None
 
3536
                try:
 
3537
                    target_dir = BzrDir.open(stack_on,
 
3538
                        possible_transports=[self._bzrdir.root_transport])
 
3539
                except errors.NotBranchError:
 
3540
                    # Nothing there, don't change formats
 
3541
                    pass
 
3542
                except errors.JailBreak:
 
3543
                    # stack_on is inaccessible, JFDI.
 
3544
                    if format.repository_format.rich_root_data:
 
3545
                        repo_format = pack_repo.RepositoryFormatKnitPack6RichRoot()
 
3546
                    else:
 
3547
                        repo_format = pack_repo.RepositoryFormatKnitPack6()
 
3548
                    branch_format = branch.BzrBranchFormat7()
 
3549
                else:
 
3550
                    try:
 
3551
                        target_branch = target_dir.open_branch()
 
3552
                    except errors.NotBranchError:
 
3553
                        # No branch, don't change formats
 
3554
                        pass
 
3555
                    else:
 
3556
                        branch_format = target_branch._format
 
3557
                        repo_format = target_branch.repository._format
 
3558
                        if not (branch_format.supports_stacking()
 
3559
                            and repo_format.supports_external_lookups):
 
3560
                            # Doesn't stack itself, don't force an upgrade
 
3561
                            branch_format = None
 
3562
                            repo_format = None
 
3563
                if branch_format and repo_format:
 
3564
                    # Does support stacking, use its format.
 
3565
                    format.repository_format = repo_format
 
3566
                    format.set_branch_format(branch_format)
 
3567
                    note('Source format does not support stacking, '
 
3568
                        'using format: \'%s\'\n  %s\n',
 
3569
                        branch_format.get_format_description(),
 
3570
                        repo_format.get_format_description())
3681
3571
            if not self._require_stacking:
3682
3572
                # We have picked up automatic stacking somewhere.
3683
3573
                note('Using default stacking branch %s at %s', self._stack_on,
3726
3616
format_registry.register('weave', BzrDirFormat6,
3727
3617
    'Pre-0.8 format.  Slower than knit and does not'
3728
3618
    ' support checkouts or shared repositories.',
3729
 
    hidden=True,
3730
3619
    deprecated=True)
3731
3620
format_registry.register_metadir('metaweave',
3732
3621
    'bzrlib.repofmt.weaverepo.RepositoryFormat7',
3733
3622
    'Transitional format in 0.8.  Slower than knit.',
3734
3623
    branch_format='bzrlib.branch.BzrBranchFormat5',
3735
3624
    tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3736
 
    hidden=True,
3737
3625
    deprecated=True)
3738
3626
format_registry.register_metadir('knit',
3739
3627
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3740
3628
    'Format using knits.  Recommended for interoperation with bzr <= 0.14.',
3741
3629
    branch_format='bzrlib.branch.BzrBranchFormat5',
3742
3630
    tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3743
 
    hidden=True,
3744
3631
    deprecated=True)
3745
3632
format_registry.register_metadir('dirstate',
3746
3633
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3750
3637
    # this uses bzrlib.workingtree.WorkingTreeFormat4 because importing
3751
3638
    # directly from workingtree_4 triggers a circular import.
3752
3639
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3753
 
    hidden=True,
3754
3640
    deprecated=True)
3755
3641
format_registry.register_metadir('dirstate-tags',
3756
3642
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3759
3645
        ' Incompatible with bzr < 0.15.',
3760
3646
    branch_format='bzrlib.branch.BzrBranchFormat6',
3761
3647
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3762
 
    hidden=True,
3763
3648
    deprecated=True)
3764
3649
format_registry.register_metadir('rich-root',
3765
3650
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit4',
3767
3652
        ' bzr < 1.0.',
3768
3653
    branch_format='bzrlib.branch.BzrBranchFormat6',
3769
3654
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3770
 
    hidden=True,
3771
3655
    deprecated=True)
3772
3656
format_registry.register_metadir('dirstate-with-subtree',
3773
3657
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
3784
3668
    help='New in 0.92: Pack-based format with data compatible with '
3785
3669
        'dirstate-tags format repositories. Interoperates with '
3786
3670
        'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3787
 
        ,
 
3671
        'Previously called knitpack-experimental.  '
 
3672
        'For more information, see '
 
3673
        'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
3788
3674
    branch_format='bzrlib.branch.BzrBranchFormat6',
3789
3675
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3790
3676
    )
3793
3679
    help='New in 0.92: Pack-based format with data compatible with '
3794
3680
        'dirstate-with-subtree format repositories. Interoperates with '
3795
3681
        'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3796
 
        ,
 
3682
        'Previously called knitpack-experimental.  '
 
3683
        'For more information, see '
 
3684
        'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
3797
3685
    branch_format='bzrlib.branch.BzrBranchFormat6',
3798
3686
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3799
3687
    hidden=True,
3805
3693
         '(needed for bzr-svn and bzr-git).',
3806
3694
    branch_format='bzrlib.branch.BzrBranchFormat6',
3807
3695
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3808
 
    hidden=True,
3809
3696
    )
3810
3697
format_registry.register_metadir('1.6',
3811
3698
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5',
3814
3701
         'not present locally.',
3815
3702
    branch_format='bzrlib.branch.BzrBranchFormat7',
3816
3703
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3817
 
    hidden=True,
3818
3704
    )
3819
3705
format_registry.register_metadir('1.6.1-rich-root',
3820
3706
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5RichRoot',
3822
3708
         '(needed for bzr-svn and bzr-git).',
3823
3709
    branch_format='bzrlib.branch.BzrBranchFormat7',
3824
3710
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3825
 
    hidden=True,
3826
3711
    )
3827
3712
format_registry.register_metadir('1.9',
3828
3713
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3831
3716
         'performance for most operations.',
3832
3717
    branch_format='bzrlib.branch.BzrBranchFormat7',
3833
3718
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3834
 
    hidden=True,
3835
3719
    )
3836
3720
format_registry.register_metadir('1.9-rich-root',
3837
3721
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3839
3723
         '(needed for bzr-svn and bzr-git).',
3840
3724
    branch_format='bzrlib.branch.BzrBranchFormat7',
3841
3725
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3842
 
    hidden=True,
3843
3726
    )
3844
3727
format_registry.register_metadir('1.14',
3845
3728
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3861
3744
        'to and from rich-root-pack (and anything compatible with '
3862
3745
        'rich-root-pack) format repositories. Repositories and branches in '
3863
3746
        'this format can only be read by bzr.dev. Please read '
3864
 
        'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
 
3747
        'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3865
3748
        'before use.',
3866
3749
    branch_format='bzrlib.branch.BzrBranchFormat7',
3867
3750
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3868
3751
    experimental=True,
3869
3752
    alias=True,
3870
 
    hidden=True,
3871
3753
    )
3872
3754
format_registry.register_metadir('development-subtree',
3873
3755
    'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
3875
3757
        'from pack-0.92-subtree (and anything compatible with '
3876
3758
        'pack-0.92-subtree) format repositories. Repositories and branches in '
3877
3759
        'this format can only be read by bzr.dev. Please read '
3878
 
        'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
 
3760
        'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3879
3761
        'before use.',
3880
3762
    branch_format='bzrlib.branch.BzrBranchFormat7',
3881
3763
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3882
3764
    experimental=True,
3883
 
    hidden=True,
3884
3765
    alias=False, # Restore to being an alias when an actual development subtree format is added
3885
3766
                 # This current non-alias status is simply because we did not introduce a
3886
3767
                 # chk based subtree format.
3891
3772
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK1',
3892
3773
    help='pack-1.9 with 255-way hashed CHK inv, group compress, rich roots '
3893
3774
        'Please read '
3894
 
        'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3895
 
        'before use.',
3896
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3897
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3898
 
    hidden=True,
3899
 
    experimental=True,
3900
 
    )
3901
 
 
3902
 
format_registry.register_metadir('development7-rich-root',
3903
 
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK2',
3904
 
    help='pack-1.9 with 255-way hashed CHK inv, bencode revision, group compress, '
3905
 
        'rich roots. Please read '
3906
 
        'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3907
 
        'before use.',
3908
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3909
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3910
 
    hidden=True,
3911
 
    experimental=True,
3912
 
    )
3913
 
 
3914
 
format_registry.register_metadir('2a',
3915
 
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
3916
 
    help='First format for bzr 2.0 series.\n'
3917
 
        'Uses group-compress storage.\n'
3918
 
        'Provides rich roots which are a one-way transition.\n',
3919
 
        # 'storage in packs, 255-way hashed CHK inventory, bencode revision, group compress, '
3920
 
        # 'rich roots. Supported by bzr 1.16 and later.',
3921
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3922
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
 
3775
        'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
 
3776
        'before use.',
 
3777
    branch_format='bzrlib.branch.BzrBranchFormat7',
 
3778
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
 
3779
    hidden=True,
3923
3780
    experimental=True,
3924
3781
    )
3925
3782
 
3926
3783
# The following format should be an alias for the rich root equivalent 
3927
3784
# of the default format
3928
3785
format_registry.register_metadir('default-rich-root',
3929
 
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
3930
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3931
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
 
3786
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack4',
 
3787
    help='Default format, rich root variant. (needed for bzr-svn and bzr-git).',
 
3788
    branch_format='bzrlib.branch.BzrBranchFormat6',
 
3789
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3932
3790
    alias=True,
3933
 
    hidden=True,
3934
 
    help='Same as 2a.')
3935
 
 
 
3791
    )
3936
3792
# The current format that is made on 'bzr init'.
3937
 
format_registry.set_default('2a')
 
3793
format_registry.set_default('pack-0.92')