/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/bzrdir.py

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bzrdir.py
34
34
from bzrlib.lazy_import import lazy_import
35
35
lazy_import(globals(), """
36
36
from stat import S_ISDIR
 
37
import textwrap
37
38
 
38
39
import bzrlib
39
40
from bzrlib import (
40
41
    branch,
41
42
    config,
42
 
    controldir,
43
43
    errors,
44
44
    graph,
45
45
    lockable_files,
86
86
    registry,
87
87
    symbol_versioning,
88
88
    )
89
 
 
90
 
 
91
 
class BzrDir(controldir.ControlDir):
 
89
    
 
90
    
 
91
class ControlComponent(object):
 
92
    """Abstract base class for control directory components.
 
93
    
 
94
    This provides interfaces that are common across bzrdirs, 
 
95
    repositories, branches, and workingtree control directories.
 
96
    
 
97
    They all expose two urls and transports: the *user* URL is the 
 
98
    one that stops above the control directory (eg .bzr) and that 
 
99
    should normally be used in messages, and the *control* URL is
 
100
    under that in eg .bzr/checkout and is used to read the control
 
101
    files.
 
102
    
 
103
    This can be used as a mixin and is intended to fit with 
 
104
    foreign formats.
 
105
    """
 
106
    
 
107
    @property
 
108
    def control_transport(self):
 
109
        raise NotImplementedError
 
110
   
 
111
    @property
 
112
    def control_url(self):
 
113
        return self.control_transport.base
 
114
    
 
115
    @property
 
116
    def user_transport(self):
 
117
        raise NotImplementedError
 
118
        
 
119
    @property
 
120
    def user_url(self):
 
121
        return self.user_transport.base
 
122
    
 
123
 
 
124
class BzrDir(ControlComponent):
92
125
    """A .bzr control diretory.
93
126
 
94
127
    BzrDir instances let you create or open any of the things that can be
125
158
                    return
126
159
        thing_to_unlock.break_lock()
127
160
 
 
161
    def can_convert_format(self):
 
162
        """Return true if this bzrdir is one whose format we can convert from."""
 
163
        return True
 
164
 
128
165
    def check_conversion_target(self, target_format):
129
166
        """Check that a bzrdir as a whole can be converted to a new format."""
130
167
        # The only current restriction is that the repository content can be 
204
241
        """
205
242
        # Overview: put together a broad description of what we want to end up
206
243
        # with; then make as few api calls as possible to do it.
207
 
 
 
244
        
208
245
        # We may want to create a repo/branch/tree, if we do so what format
209
246
        # would we want for each:
210
247
        require_stacking = (stacked_on is not None)
211
248
        format = self.cloning_metadir(require_stacking)
212
 
 
 
249
        
213
250
        # Figure out what objects we want:
214
251
        try:
215
252
            local_repo = self.find_repository()
292
329
        t = get_transport(url)
293
330
        t.ensure_base()
294
331
 
 
332
    @classmethod
 
333
    def create(cls, base, format=None, possible_transports=None):
 
334
        """Create a new BzrDir at the url 'base'.
 
335
 
 
336
        :param format: If supplied, the format of branch to create.  If not
 
337
            supplied, the default is used.
 
338
        :param possible_transports: If supplied, a list of transports that
 
339
            can be reused to share a remote connection.
 
340
        """
 
341
        if cls is not BzrDir:
 
342
            raise AssertionError("BzrDir.create always creates the default"
 
343
                " format, not one of %r" % cls)
 
344
        t = get_transport(base, possible_transports)
 
345
        t.ensure_base()
 
346
        if format is None:
 
347
            format = BzrDirFormat.get_default_format()
 
348
        return format.initialize_on_transport(t)
 
349
 
295
350
    @staticmethod
296
351
    def find_bzrdirs(transport, evaluate=None, list_current=None):
297
352
        """Find bzrdirs recursively from current location.
320
375
            recurse = True
321
376
            try:
322
377
                bzrdir = BzrDir.open_from_transport(current_transport)
323
 
            except (errors.NotBranchError, errors.PermissionDenied):
 
378
            except errors.NotBranchError:
324
379
                pass
325
380
            else:
326
381
                recurse, value = evaluate(bzrdir)
327
382
                yield value
328
383
            try:
329
384
                subdirs = list_current(current_transport)
330
 
            except (errors.NoSuchFile, errors.PermissionDenied):
 
385
            except errors.NoSuchFile:
331
386
                continue
332
387
            if recurse:
333
388
                for subdir in sorted(subdirs, reverse=True):
334
389
                    pending.append(current_transport.clone(subdir))
335
390
 
 
391
    def list_branches(self):
 
392
        """Return a sequence of all branches local to this control directory.
 
393
 
 
394
        """
 
395
        try:
 
396
            return [self.open_branch()]
 
397
        except errors.NotBranchError:
 
398
            return []
 
399
 
336
400
    @staticmethod
337
401
    def find_branches(transport):
338
402
        """Find all branches under a transport.
361
425
                ret.extend(branches)
362
426
        return ret
363
427
 
 
428
    def destroy_repository(self):
 
429
        """Destroy the repository in this BzrDir"""
 
430
        raise NotImplementedError(self.destroy_repository)
 
431
 
 
432
    def create_branch(self, name=None):
 
433
        """Create a branch in this BzrDir.
 
434
 
 
435
        :param name: Name of the colocated branch to create, None for
 
436
            the default branch.
 
437
 
 
438
        The bzrdir's format will control what branch format is created.
 
439
        For more control see BranchFormatXX.create(a_bzrdir).
 
440
        """
 
441
        raise NotImplementedError(self.create_branch)
 
442
 
 
443
    def destroy_branch(self, name=None):
 
444
        """Destroy a branch in this BzrDir.
 
445
        
 
446
        :param name: Name of the branch to destroy, None for the default 
 
447
            branch.
 
448
        """
 
449
        raise NotImplementedError(self.destroy_branch)
 
450
 
364
451
    @staticmethod
365
452
    def create_branch_and_repo(base, force_new_repo=False, format=None):
366
453
        """Create a new BzrDir, Branch and Repository at the url 'base'.
515
602
                                               format=format).bzrdir
516
603
        return bzrdir.create_workingtree()
517
604
 
518
 
    def generate_backup_name(self, base):
519
 
        """Generate a non-existing backup file name based on base."""
520
 
        counter = 1
521
 
        name = "%s.~%d~" % (base, counter)
522
 
        while self.root_transport.has(name):
523
 
            counter += 1
524
 
            name = "%s.~%d~" % (base, counter)
525
 
        return name
 
605
    def create_workingtree(self, revision_id=None, from_branch=None,
 
606
        accelerator_tree=None, hardlink=False):
 
607
        """Create a working tree at this BzrDir.
 
608
 
 
609
        :param revision_id: create it as of this revision id.
 
610
        :param from_branch: override bzrdir branch (for lightweight checkouts)
 
611
        :param accelerator_tree: A tree which can be used for retrieving file
 
612
            contents more quickly than the revision tree, i.e. a workingtree.
 
613
            The revision tree will be used for cases where accelerator_tree's
 
614
            content is different.
 
615
        """
 
616
        raise NotImplementedError(self.create_workingtree)
526
617
 
527
618
    def backup_bzrdir(self):
528
619
        """Backup this bzr control directory.
529
620
 
530
621
        :return: Tuple with old path name and new path name
531
622
        """
 
623
        def name_gen(base='backup.bzr'):
 
624
            counter = 1
 
625
            name = "%s.~%d~" % (base, counter)
 
626
            while self.root_transport.has(name):
 
627
                counter += 1
 
628
                name = "%s.~%d~" % (base, counter)
 
629
            return name
532
630
 
533
 
        backup_dir=self.generate_backup_name('backup.bzr')
 
631
        backup_dir=name_gen()
534
632
        pb = ui.ui_factory.nested_progress_bar()
535
633
        try:
536
634
            # FIXME: bug 300001 -- the backup fails if the backup directory
570
668
                else:
571
669
                    pass
572
670
 
 
671
    def destroy_workingtree(self):
 
672
        """Destroy the working tree at this BzrDir.
 
673
 
 
674
        Formats that do not support this may raise UnsupportedOperation.
 
675
        """
 
676
        raise NotImplementedError(self.destroy_workingtree)
 
677
 
 
678
    def destroy_workingtree_metadata(self):
 
679
        """Destroy the control files for the working tree at this BzrDir.
 
680
 
 
681
        The contents of working tree files are not affected.
 
682
        Formats that do not support this may raise UnsupportedOperation.
 
683
        """
 
684
        raise NotImplementedError(self.destroy_workingtree_metadata)
 
685
 
573
686
    def _find_containing(self, evaluate):
574
687
        """Find something in a containing control directory.
575
688
 
624
737
            raise errors.NoRepositoryPresent(self)
625
738
        return found_repo
626
739
 
 
740
    def get_branch_reference(self):
 
741
        """Return the referenced URL for the branch in this bzrdir.
 
742
 
 
743
        :raises NotBranchError: If there is no Branch.
 
744
        :return: The URL the branch in this bzrdir references if it is a
 
745
            reference branch, or None for regular branches.
 
746
        """
 
747
        return None
 
748
 
 
749
    def get_branch_transport(self, branch_format, name=None):
 
750
        """Get the transport for use by branch format in this BzrDir.
 
751
 
 
752
        Note that bzr dirs that do not support format strings will raise
 
753
        IncompatibleFormat if the branch format they are given has
 
754
        a format string, and vice versa.
 
755
 
 
756
        If branch_format is None, the transport is returned with no
 
757
        checking. If it is not None, then the returned transport is
 
758
        guaranteed to point to an existing directory ready for use.
 
759
        """
 
760
        raise NotImplementedError(self.get_branch_transport)
 
761
 
627
762
    def _find_creation_modes(self):
628
763
        """Determine the appropriate modes for files and directories.
629
764
 
668
803
            self._find_creation_modes()
669
804
        return self._dir_mode
670
805
 
 
806
    def get_repository_transport(self, repository_format):
 
807
        """Get the transport for use by repository format in this BzrDir.
 
808
 
 
809
        Note that bzr dirs that do not support format strings will raise
 
810
        IncompatibleFormat if the repository format they are given has
 
811
        a format string, and vice versa.
 
812
 
 
813
        If repository_format is None, the transport is returned with no
 
814
        checking. If it is not None, then the returned transport is
 
815
        guaranteed to point to an existing directory ready for use.
 
816
        """
 
817
        raise NotImplementedError(self.get_repository_transport)
 
818
 
 
819
    def get_workingtree_transport(self, tree_format):
 
820
        """Get the transport for use by workingtree format in this BzrDir.
 
821
 
 
822
        Note that bzr dirs that do not support format strings will raise
 
823
        IncompatibleFormat if the workingtree format they are given has a
 
824
        format string, and vice versa.
 
825
 
 
826
        If workingtree_format is None, the transport is returned with no
 
827
        checking. If it is not None, then the returned transport is
 
828
        guaranteed to point to an existing directory ready for use.
 
829
        """
 
830
        raise NotImplementedError(self.get_workingtree_transport)
 
831
 
671
832
    def get_config(self):
672
833
        """Get configuration for this BzrDir."""
673
834
        return config.BzrDirConfig(self)
691
852
        self.transport = _transport.clone('.bzr')
692
853
        self.root_transport = _transport
693
854
        self._mode_check_done = False
694
 
 
 
855
        
695
856
    @property 
696
857
    def user_transport(self):
697
858
        return self.root_transport
698
 
 
 
859
        
699
860
    @property
700
861
    def control_transport(self):
701
862
        return self.transport
707
868
 
708
869
        This is true IF and ONLY IF the filename is part of the namespace reserved
709
870
        for bzr control dirs. Currently this is the '.bzr' directory in the root
710
 
        of the root_transport. 
 
871
        of the root_transport. it is expected that plugins will need to extend
 
872
        this in the future - for instance to make bzr talk with svn working
 
873
        trees.
711
874
        """
712
875
        # this might be better on the BzrDirFormat class because it refers to
713
876
        # all the possible bzrdir disk formats.
717
880
        # add new tests for it to the appropriate place.
718
881
        return filename == '.bzr' or filename.startswith('.bzr/')
719
882
 
 
883
    def needs_format_conversion(self, format=None):
 
884
        """Return true if this bzrdir needs convert_format run on it.
 
885
 
 
886
        For instance, if the repository format is out of date but the
 
887
        branch and working tree are not, this should return True.
 
888
 
 
889
        :param format: Optional parameter indicating a specific desired
 
890
                       format we plan to arrive at.
 
891
        """
 
892
        raise NotImplementedError(self.needs_format_conversion)
 
893
 
720
894
    @staticmethod
721
895
    def open_unsupported(base):
722
896
        """Open a branch which is not supported."""
745
919
        # the redirections.
746
920
        base = transport.base
747
921
        def find_format(transport):
748
 
            return transport, controldir.ControlDirFormat.find_format(
 
922
            return transport, BzrDirFormat.find_format(
749
923
                transport, _server_formats=_server_formats)
750
924
 
751
925
        def redirected(transport, e, redirection_notice):
766
940
        BzrDir._check_supported(format, _unsupported)
767
941
        return format.open(transport, _found=True)
768
942
 
 
943
    def open_branch(self, name=None, unsupported=False,
 
944
                    ignore_fallbacks=False):
 
945
        """Open the branch object at this BzrDir if one is present.
 
946
 
 
947
        If unsupported is True, then no longer supported branch formats can
 
948
        still be opened.
 
949
 
 
950
        TODO: static convenience version of this?
 
951
        """
 
952
        raise NotImplementedError(self.open_branch)
 
953
 
769
954
    @staticmethod
770
955
    def open_containing(url, possible_transports=None):
771
956
        """Open an existing branch which contains url.
809
994
                raise errors.NotBranchError(path=url)
810
995
            a_transport = new_t
811
996
 
 
997
    def _get_tree_branch(self):
 
998
        """Return the branch and tree, if any, for this bzrdir.
 
999
 
 
1000
        Return None for tree if not present or inaccessible.
 
1001
        Raise NotBranchError if no branch is present.
 
1002
        :return: (tree, branch)
 
1003
        """
 
1004
        try:
 
1005
            tree = self.open_workingtree()
 
1006
        except (errors.NoWorkingTree, errors.NotLocalUrl):
 
1007
            tree = None
 
1008
            branch = self.open_branch()
 
1009
        else:
 
1010
            branch = tree.branch
 
1011
        return tree, branch
 
1012
 
812
1013
    @classmethod
813
1014
    def open_tree_or_branch(klass, location):
814
1015
        """Return the branch and working tree at a location.
860
1061
                raise errors.NotBranchError(location)
861
1062
        return tree, branch, branch.repository, relpath
862
1063
 
 
1064
    def open_repository(self, _unsupported=False):
 
1065
        """Open the repository object at this BzrDir if one is present.
 
1066
 
 
1067
        This will not follow the Branch object pointer - it's strictly a direct
 
1068
        open facility. Most client code should use open_branch().repository to
 
1069
        get at a repository.
 
1070
 
 
1071
        :param _unsupported: a private parameter, not part of the api.
 
1072
        TODO: static convenience version of this?
 
1073
        """
 
1074
        raise NotImplementedError(self.open_repository)
 
1075
 
 
1076
    def open_workingtree(self, _unsupported=False,
 
1077
                         recommend_upgrade=True, from_branch=None):
 
1078
        """Open the workingtree object at this BzrDir if one is present.
 
1079
 
 
1080
        :param recommend_upgrade: Optional keyword parameter, when True (the
 
1081
            default), emit through the ui module a recommendation that the user
 
1082
            upgrade the working tree when the workingtree being opened is old
 
1083
            (but still fully supported).
 
1084
        :param from_branch: override bzrdir branch (for lightweight checkouts)
 
1085
        """
 
1086
        raise NotImplementedError(self.open_workingtree)
 
1087
 
 
1088
    def has_branch(self, name=None):
 
1089
        """Tell if this bzrdir contains a branch.
 
1090
 
 
1091
        Note: if you're going to open the branch, you should just go ahead
 
1092
        and try, and not ask permission first.  (This method just opens the
 
1093
        branch and discards it, and that's somewhat expensive.)
 
1094
        """
 
1095
        try:
 
1096
            self.open_branch(name)
 
1097
            return True
 
1098
        except errors.NotBranchError:
 
1099
            return False
 
1100
 
 
1101
    def has_workingtree(self):
 
1102
        """Tell if this bzrdir contains a working tree.
 
1103
 
 
1104
        This will still raise an exception if the bzrdir has a workingtree that
 
1105
        is remote & inaccessible.
 
1106
 
 
1107
        Note: if you're going to open the working tree, you should just go ahead
 
1108
        and try, and not ask permission first.  (This method just opens the
 
1109
        workingtree and discards it, and that's somewhat expensive.)
 
1110
        """
 
1111
        try:
 
1112
            self.open_workingtree(recommend_upgrade=False)
 
1113
            return True
 
1114
        except errors.NoWorkingTree:
 
1115
            return False
 
1116
 
863
1117
    def _cloning_metadir(self):
864
1118
        """Produce a metadir suitable for cloning with.
865
1119
 
923
1177
            format.require_stacking()
924
1178
        return format
925
1179
 
926
 
    @classmethod
927
 
    def create(cls, base, format=None, possible_transports=None):
928
 
        """Create a new BzrDir at the url 'base'.
929
 
 
930
 
        :param format: If supplied, the format of branch to create.  If not
931
 
            supplied, the default is used.
932
 
        :param possible_transports: If supplied, a list of transports that
933
 
            can be reused to share a remote connection.
 
1180
    def checkout_metadir(self):
 
1181
        return self.cloning_metadir()
 
1182
 
 
1183
    def sprout(self, url, revision_id=None, force_new_repo=False,
 
1184
               recurse='down', possible_transports=None,
 
1185
               accelerator_tree=None, hardlink=False, stacked=False,
 
1186
               source_branch=None, create_tree_if_local=True):
 
1187
        """Create a copy of this bzrdir prepared for use as a new line of
 
1188
        development.
 
1189
 
 
1190
        If url's last component does not exist, it will be created.
 
1191
 
 
1192
        Attributes related to the identity of the source branch like
 
1193
        branch nickname will be cleaned, a working tree is created
 
1194
        whether one existed before or not; and a local branch is always
 
1195
        created.
 
1196
 
 
1197
        if revision_id is not None, then the clone operation may tune
 
1198
            itself to download less data.
 
1199
        :param accelerator_tree: A tree which can be used for retrieving file
 
1200
            contents more quickly than the revision tree, i.e. a workingtree.
 
1201
            The revision tree will be used for cases where accelerator_tree's
 
1202
            content is different.
 
1203
        :param hardlink: If true, hard-link files from accelerator_tree,
 
1204
            where possible.
 
1205
        :param stacked: If true, create a stacked branch referring to the
 
1206
            location of this control directory.
 
1207
        :param create_tree_if_local: If true, a working-tree will be created
 
1208
            when working locally.
934
1209
        """
935
 
        if cls is not BzrDir:
936
 
            raise AssertionError("BzrDir.create always creates the"
937
 
                "default format, not one of %r" % cls)
938
 
        t = get_transport(base, possible_transports)
939
 
        t.ensure_base()
940
 
        if format is None:
941
 
            format = controldir.ControlDirFormat.get_default_format()
942
 
        return format.initialize_on_transport(t)
943
 
 
 
1210
        target_transport = get_transport(url, possible_transports)
 
1211
        target_transport.ensure_base()
 
1212
        cloning_format = self.cloning_metadir(stacked)
 
1213
        # Create/update the result branch
 
1214
        result = cloning_format.initialize_on_transport(target_transport)
 
1215
        # if a stacked branch wasn't requested, we don't create one
 
1216
        # even if the origin was stacked
 
1217
        stacked_branch_url = None
 
1218
        if source_branch is not None:
 
1219
            if stacked:
 
1220
                stacked_branch_url = self.root_transport.base
 
1221
            source_repository = source_branch.repository
 
1222
        else:
 
1223
            try:
 
1224
                source_branch = self.open_branch()
 
1225
                source_repository = source_branch.repository
 
1226
                if stacked:
 
1227
                    stacked_branch_url = self.root_transport.base
 
1228
            except errors.NotBranchError:
 
1229
                source_branch = None
 
1230
                try:
 
1231
                    source_repository = self.open_repository()
 
1232
                except errors.NoRepositoryPresent:
 
1233
                    source_repository = None
 
1234
        repository_policy = result.determine_repository_policy(
 
1235
            force_new_repo, stacked_branch_url, require_stacking=stacked)
 
1236
        result_repo, is_new_repo = repository_policy.acquire_repository()
 
1237
        if is_new_repo and revision_id is not None and not stacked:
 
1238
            fetch_spec = graph.PendingAncestryResult(
 
1239
                [revision_id], source_repository)
 
1240
        else:
 
1241
            fetch_spec = None
 
1242
        if source_repository is not None:
 
1243
            # Fetch while stacked to prevent unstacked fetch from
 
1244
            # Branch.sprout.
 
1245
            if fetch_spec is None:
 
1246
                result_repo.fetch(source_repository, revision_id=revision_id)
 
1247
            else:
 
1248
                result_repo.fetch(source_repository, fetch_spec=fetch_spec)
 
1249
 
 
1250
        if source_branch is None:
 
1251
            # this is for sprouting a bzrdir without a branch; is that
 
1252
            # actually useful?
 
1253
            # Not especially, but it's part of the contract.
 
1254
            result_branch = result.create_branch()
 
1255
        else:
 
1256
            result_branch = source_branch.sprout(result,
 
1257
                revision_id=revision_id, repository_policy=repository_policy)
 
1258
        mutter("created new branch %r" % (result_branch,))
 
1259
 
 
1260
        # Create/update the result working tree
 
1261
        if (create_tree_if_local and
 
1262
            isinstance(target_transport, local.LocalTransport) and
 
1263
            (result_repo is None or result_repo.make_working_trees())):
 
1264
            wt = result.create_workingtree(accelerator_tree=accelerator_tree,
 
1265
                hardlink=hardlink)
 
1266
            wt.lock_write()
 
1267
            try:
 
1268
                if wt.path2id('') is None:
 
1269
                    try:
 
1270
                        wt.set_root_id(self.open_workingtree.get_root_id())
 
1271
                    except errors.NoWorkingTree:
 
1272
                        pass
 
1273
            finally:
 
1274
                wt.unlock()
 
1275
        else:
 
1276
            wt = None
 
1277
        if recurse == 'down':
 
1278
            if wt is not None:
 
1279
                basis = wt.basis_tree()
 
1280
                basis.lock_read()
 
1281
                subtrees = basis.iter_references()
 
1282
            elif result_branch is not None:
 
1283
                basis = result_branch.basis_tree()
 
1284
                basis.lock_read()
 
1285
                subtrees = basis.iter_references()
 
1286
            elif source_branch is not None:
 
1287
                basis = source_branch.basis_tree()
 
1288
                basis.lock_read()
 
1289
                subtrees = basis.iter_references()
 
1290
            else:
 
1291
                subtrees = []
 
1292
                basis = None
 
1293
            try:
 
1294
                for path, file_id in subtrees:
 
1295
                    target = urlutils.join(url, urlutils.escape(path))
 
1296
                    sublocation = source_branch.reference_parent(file_id, path)
 
1297
                    sublocation.bzrdir.sprout(target,
 
1298
                        basis.get_reference_revision(file_id, path),
 
1299
                        force_new_repo=force_new_repo, recurse=recurse,
 
1300
                        stacked=stacked)
 
1301
            finally:
 
1302
                if basis is not None:
 
1303
                    basis.unlock()
 
1304
        return result
 
1305
 
 
1306
    def push_branch(self, source, revision_id=None, overwrite=False, 
 
1307
        remember=False, create_prefix=False):
 
1308
        """Push the source branch into this BzrDir."""
 
1309
        br_to = None
 
1310
        # If we can open a branch, use its direct repository, otherwise see
 
1311
        # if there is a repository without a branch.
 
1312
        try:
 
1313
            br_to = self.open_branch()
 
1314
        except errors.NotBranchError:
 
1315
            # Didn't find a branch, can we find a repository?
 
1316
            repository_to = self.find_repository()
 
1317
        else:
 
1318
            # Found a branch, so we must have found a repository
 
1319
            repository_to = br_to.repository
 
1320
 
 
1321
        push_result = PushResult()
 
1322
        push_result.source_branch = source
 
1323
        if br_to is None:
 
1324
            # We have a repository but no branch, copy the revisions, and then
 
1325
            # create a branch.
 
1326
            repository_to.fetch(source.repository, revision_id=revision_id)
 
1327
            br_to = source.clone(self, revision_id=revision_id)
 
1328
            if source.get_push_location() is None or remember:
 
1329
                source.set_push_location(br_to.base)
 
1330
            push_result.stacked_on = None
 
1331
            push_result.branch_push_result = None
 
1332
            push_result.old_revno = None
 
1333
            push_result.old_revid = _mod_revision.NULL_REVISION
 
1334
            push_result.target_branch = br_to
 
1335
            push_result.master_branch = None
 
1336
            push_result.workingtree_updated = False
 
1337
        else:
 
1338
            # We have successfully opened the branch, remember if necessary:
 
1339
            if source.get_push_location() is None or remember:
 
1340
                source.set_push_location(br_to.base)
 
1341
            try:
 
1342
                tree_to = self.open_workingtree()
 
1343
            except errors.NotLocalUrl:
 
1344
                push_result.branch_push_result = source.push(br_to, 
 
1345
                    overwrite, stop_revision=revision_id)
 
1346
                push_result.workingtree_updated = False
 
1347
            except errors.NoWorkingTree:
 
1348
                push_result.branch_push_result = source.push(br_to,
 
1349
                    overwrite, stop_revision=revision_id)
 
1350
                push_result.workingtree_updated = None # Not applicable
 
1351
            else:
 
1352
                tree_to.lock_write()
 
1353
                try:
 
1354
                    push_result.branch_push_result = source.push(
 
1355
                        tree_to.branch, overwrite, stop_revision=revision_id)
 
1356
                    tree_to.update()
 
1357
                finally:
 
1358
                    tree_to.unlock()
 
1359
                push_result.workingtree_updated = True
 
1360
            push_result.old_revno = push_result.branch_push_result.old_revno
 
1361
            push_result.old_revid = push_result.branch_push_result.old_revid
 
1362
            push_result.target_branch = \
 
1363
                push_result.branch_push_result.target_branch
 
1364
        return push_result
944
1365
 
945
1366
 
946
1367
class BzrDirHooks(hooks.Hooks):
1016
1437
    def cloning_metadir(self, require_stacking=False):
1017
1438
        """Produce a metadir suitable for cloning with."""
1018
1439
        if require_stacking:
1019
 
            return controldir.format_registry.make_bzrdir('1.6')
 
1440
            return format_registry.make_bzrdir('1.6')
1020
1441
        return self._format.__class__()
1021
1442
 
1022
1443
    def clone(self, url, revision_id=None, force_new_repo=False,
1315
1736
    def destroy_workingtree_metadata(self):
1316
1737
        self.transport.delete_tree('checkout')
1317
1738
 
1318
 
    def find_branch_format(self, name=None):
 
1739
    def find_branch_format(self):
1319
1740
        """Find the branch 'format' for this bzrdir.
1320
1741
 
1321
1742
        This might be a synthetic object for e.g. RemoteBranch and SVN.
1322
1743
        """
1323
1744
        from bzrlib.branch import BranchFormat
1324
 
        return BranchFormat.find_format(self, name=name)
 
1745
        return BranchFormat.find_format(self)
1325
1746
 
1326
1747
    def _get_mkdir_mode(self):
1327
1748
        """Figure out the mode to use when creating a bzrdir subdir."""
1329
1750
                                     lockable_files.TransportLock)
1330
1751
        return temp_control._dir_mode
1331
1752
 
1332
 
    def get_branch_reference(self, name=None):
 
1753
    def get_branch_reference(self):
1333
1754
        """See BzrDir.get_branch_reference()."""
1334
1755
        from bzrlib.branch import BranchFormat
1335
 
        format = BranchFormat.find_format(self, name=name)
1336
 
        return format.get_reference(self, name=name)
 
1756
        format = BranchFormat.find_format(self)
 
1757
        return format.get_reference(self)
1337
1758
 
1338
1759
    def get_branch_transport(self, branch_format, name=None):
1339
1760
        """See BzrDir.get_branch_transport()."""
1433
1854
    def open_branch(self, name=None, unsupported=False,
1434
1855
                    ignore_fallbacks=False):
1435
1856
        """See BzrDir.open_branch."""
1436
 
        format = self.find_branch_format(name=name)
 
1857
        format = self.find_branch_format()
1437
1858
        self._check_supported(format, unsupported)
1438
1859
        return format.open(self, name=name,
1439
1860
            _found=True, ignore_fallbacks=ignore_fallbacks)
1459
1880
        return config.TransportConfig(self.transport, 'control.conf')
1460
1881
 
1461
1882
 
1462
 
class BzrProber(controldir.Prober):
1463
 
    """Prober for formats that use a .bzr/ control directory."""
1464
 
 
1465
 
    _formats = {}
1466
 
    """The known .bzr formats."""
1467
 
 
1468
 
    @classmethod
1469
 
    def register_bzrdir_format(klass, format):
1470
 
        klass._formats[format.get_format_string()] = format
1471
 
 
1472
 
    @classmethod
1473
 
    def unregister_bzrdir_format(klass, format):
1474
 
        del klass._formats[format.get_format_string()]
1475
 
 
1476
 
    @classmethod
1477
 
    def probe_transport(klass, transport):
1478
 
        """Return the .bzrdir style format present in a directory."""
1479
 
        try:
1480
 
            format_string = transport.get_bytes(".bzr/branch-format")
1481
 
        except errors.NoSuchFile:
1482
 
            raise errors.NotBranchError(path=transport.base)
1483
 
        try:
1484
 
            return klass._formats[format_string]
1485
 
        except KeyError:
1486
 
            raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
1487
 
 
1488
 
 
1489
 
controldir.ControlDirFormat.register_prober(BzrProber)
1490
 
 
1491
 
 
1492
 
class RemoteBzrProber(controldir.Prober):
1493
 
    """Prober for remote servers that provide a Bazaar smart server."""
1494
 
 
1495
 
    @classmethod
1496
 
    def probe_transport(klass, transport):
1497
 
        """Return a RemoteBzrDirFormat object if it looks possible."""
1498
 
        try:
1499
 
            medium = transport.get_smart_medium()
1500
 
        except (NotImplementedError, AttributeError,
1501
 
                errors.TransportNotPossible, errors.NoSmartMedium,
1502
 
                errors.SmartProtocolError):
1503
 
            # no smart server, so not a branch for this format type.
1504
 
            raise errors.NotBranchError(path=transport.base)
1505
 
        else:
1506
 
            # Decline to open it if the server doesn't support our required
1507
 
            # version (3) so that the VFS-based transport will do it.
1508
 
            if medium.should_probe():
1509
 
                try:
1510
 
                    server_version = medium.protocol_version()
1511
 
                except errors.SmartProtocolError:
1512
 
                    # Apparently there's no usable smart server there, even though
1513
 
                    # the medium supports the smart protocol.
1514
 
                    raise errors.NotBranchError(path=transport.base)
1515
 
                if server_version != '2':
1516
 
                    raise errors.NotBranchError(path=transport.base)
1517
 
            return RemoteBzrDirFormat()
1518
 
 
1519
 
 
1520
 
class BzrDirFormat(controldir.ControlDirFormat):
1521
 
    """ControlDirFormat base class for .bzr/ directories.
 
1883
class BzrDirFormat(object):
 
1884
    """An encapsulation of the initialization and open routines for a format.
 
1885
 
 
1886
    Formats provide three things:
 
1887
     * An initialization routine,
 
1888
     * a format string,
 
1889
     * an open routine.
1522
1890
 
1523
1891
    Formats are placed in a dict by their format string for reference
1524
1892
    during bzrdir opening. These should be subclasses of BzrDirFormat
1527
1895
    Once a format is deprecated, just deprecate the initialize and open
1528
1896
    methods on the format class. Do not deprecate the object, as the
1529
1897
    object will be created every system load.
 
1898
 
 
1899
    :cvar colocated_branches: Whether this formats supports colocated branches.
 
1900
    """
 
1901
 
 
1902
    _default_format = None
 
1903
    """The default format used for new .bzr dirs."""
 
1904
 
 
1905
    _formats = {}
 
1906
    """The known formats."""
 
1907
 
 
1908
    _control_formats = []
 
1909
    """The registered control formats - .bzr, ....
 
1910
 
 
1911
    This is a list of BzrDirFormat objects.
 
1912
    """
 
1913
 
 
1914
    _control_server_formats = []
 
1915
    """The registered control server formats, e.g. RemoteBzrDirs.
 
1916
 
 
1917
    This is a list of BzrDirFormat objects.
1530
1918
    """
1531
1919
 
1532
1920
    _lock_file_name = 'branch-lock'
1533
1921
 
 
1922
    colocated_branches = False
 
1923
    """Whether co-located branches are supported for this control dir format.
 
1924
    """
 
1925
 
1534
1926
    # _lock_class must be set in subclasses to the lock type, typ.
1535
1927
    # TransportLock or LockDir
1536
1928
 
 
1929
    @classmethod
 
1930
    def find_format(klass, transport, _server_formats=True):
 
1931
        """Return the format present at transport."""
 
1932
        if _server_formats:
 
1933
            formats = klass._control_server_formats + klass._control_formats
 
1934
        else:
 
1935
            formats = klass._control_formats
 
1936
        for format in formats:
 
1937
            try:
 
1938
                return format.probe_transport(transport)
 
1939
            except errors.NotBranchError:
 
1940
                # this format does not find a control dir here.
 
1941
                pass
 
1942
        raise errors.NotBranchError(path=transport.base)
 
1943
 
 
1944
    @classmethod
 
1945
    def probe_transport(klass, transport):
 
1946
        """Return the .bzrdir style format present in a directory."""
 
1947
        try:
 
1948
            format_string = transport.get_bytes(".bzr/branch-format")
 
1949
        except errors.NoSuchFile:
 
1950
            raise errors.NotBranchError(path=transport.base)
 
1951
 
 
1952
        try:
 
1953
            return klass._formats[format_string]
 
1954
        except KeyError:
 
1955
            raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
 
1956
 
 
1957
    @classmethod
 
1958
    def get_default_format(klass):
 
1959
        """Return the current default format."""
 
1960
        return klass._default_format
 
1961
 
1537
1962
    def get_format_string(self):
1538
1963
        """Return the ASCII format string that identifies this format."""
1539
1964
        raise NotImplementedError(self.get_format_string)
1540
1965
 
 
1966
    def get_format_description(self):
 
1967
        """Return the short description for this format."""
 
1968
        raise NotImplementedError(self.get_format_description)
 
1969
 
 
1970
    def get_converter(self, format=None):
 
1971
        """Return the converter to use to convert bzrdirs needing converts.
 
1972
 
 
1973
        This returns a bzrlib.bzrdir.Converter object.
 
1974
 
 
1975
        This should return the best upgrader to step this format towards the
 
1976
        current default format. In the case of plugins we can/should provide
 
1977
        some means for them to extend the range of returnable converters.
 
1978
 
 
1979
        :param format: Optional format to override the default format of the
 
1980
                       library.
 
1981
        """
 
1982
        raise NotImplementedError(self.get_converter)
 
1983
 
 
1984
    def initialize(self, url, possible_transports=None):
 
1985
        """Create a bzr control dir at this url and return an opened copy.
 
1986
 
 
1987
        While not deprecated, this method is very specific and its use will
 
1988
        lead to many round trips to setup a working environment. See
 
1989
        initialize_on_transport_ex for a [nearly] all-in-one method.
 
1990
 
 
1991
        Subclasses should typically override initialize_on_transport
 
1992
        instead of this method.
 
1993
        """
 
1994
        return self.initialize_on_transport(get_transport(url,
 
1995
                                                          possible_transports))
 
1996
 
1541
1997
    def initialize_on_transport(self, transport):
1542
1998
        """Initialize a new bzrdir in the base directory of a Transport."""
1543
1999
        try:
1691
2147
            control_files.unlock()
1692
2148
        return self.open(transport, _found=True)
1693
2149
 
 
2150
    def is_supported(self):
 
2151
        """Is this format supported?
 
2152
 
 
2153
        Supported formats must be initializable and openable.
 
2154
        Unsupported formats may not support initialization or committing or
 
2155
        some other features depending on the reason for not being supported.
 
2156
        """
 
2157
        return True
 
2158
 
 
2159
    def network_name(self):
 
2160
        """A simple byte string uniquely identifying this format for RPC calls.
 
2161
 
 
2162
        Bzr control formats use thir disk format string to identify the format
 
2163
        over the wire. Its possible that other control formats have more
 
2164
        complex detection requirements, so we permit them to use any unique and
 
2165
        immutable string they desire.
 
2166
        """
 
2167
        raise NotImplementedError(self.network_name)
 
2168
 
 
2169
    def same_model(self, target_format):
 
2170
        return (self.repository_format.rich_root_data ==
 
2171
            target_format.rich_root_data)
 
2172
 
 
2173
    @classmethod
 
2174
    def known_formats(klass):
 
2175
        """Return all the known formats.
 
2176
 
 
2177
        Concrete formats should override _known_formats.
 
2178
        """
 
2179
        # There is double indirection here to make sure that control
 
2180
        # formats used by more than one dir format will only be probed
 
2181
        # once. This can otherwise be quite expensive for remote connections.
 
2182
        result = set()
 
2183
        for format in klass._control_formats:
 
2184
            result.update(format._known_formats())
 
2185
        return result
 
2186
 
 
2187
    @classmethod
 
2188
    def _known_formats(klass):
 
2189
        """Return the known format instances for this control format."""
 
2190
        return set(klass._formats.values())
 
2191
 
1694
2192
    def open(self, transport, _found=False):
1695
2193
        """Return an instance of this format for the dir transport points at.
1696
2194
 
1697
2195
        _found is a private parameter, do not use it.
1698
2196
        """
1699
2197
        if not _found:
1700
 
            found_format = controldir.ControlDirFormat.find_format(transport)
 
2198
            found_format = BzrDirFormat.find_format(transport)
1701
2199
            if not isinstance(found_format, self.__class__):
1702
2200
                raise AssertionError("%s was asked to open %s, but it seems to need "
1703
2201
                        "format %s"
1717
2215
 
1718
2216
    @classmethod
1719
2217
    def register_format(klass, format):
1720
 
        BzrProber.register_bzrdir_format(format)
 
2218
        klass._formats[format.get_format_string()] = format
1721
2219
        # bzr native formats have a network name of their format string.
1722
2220
        network_format_registry.register(format.get_format_string(), format.__class__)
1723
 
        controldir.ControlDirFormat.register_format(format)
 
2221
 
 
2222
    @classmethod
 
2223
    def register_control_format(klass, format):
 
2224
        """Register a format that does not use '.bzr' for its control dir.
 
2225
 
 
2226
        TODO: This should be pulled up into a 'ControlDirFormat' base class
 
2227
        which BzrDirFormat can inherit from, and renamed to register_format
 
2228
        there. It has been done without that for now for simplicity of
 
2229
        implementation.
 
2230
        """
 
2231
        klass._control_formats.append(format)
 
2232
 
 
2233
    @classmethod
 
2234
    def register_control_server_format(klass, format):
 
2235
        """Register a control format for client-server environments.
 
2236
 
 
2237
        These formats will be tried before ones registered with
 
2238
        register_control_format.  This gives implementations that decide to the
 
2239
        chance to grab it before anything looks at the contents of the format
 
2240
        file.
 
2241
        """
 
2242
        klass._control_server_formats.append(format)
 
2243
 
 
2244
    @classmethod
 
2245
    def _set_default_format(klass, format):
 
2246
        """Set default format (for testing behavior of defaults only)"""
 
2247
        klass._default_format = format
 
2248
 
 
2249
    def __str__(self):
 
2250
        # Trim the newline
 
2251
        return self.get_format_description().rstrip()
1724
2252
 
1725
2253
    def _supply_sub_formats_to(self, other_format):
1726
2254
        """Give other_format the same values for sub formats as this has.
1736
2264
 
1737
2265
    @classmethod
1738
2266
    def unregister_format(klass, format):
1739
 
        BzrProber.unregister_bzrdir_format(format)
1740
 
        controldir.ControlDirFormat.unregister_format(format)
1741
 
        network_format_registry.remove(format.get_format_string())
 
2267
        del klass._formats[format.get_format_string()]
 
2268
 
 
2269
    @classmethod
 
2270
    def unregister_control_format(klass, format):
 
2271
        klass._control_formats.remove(format)
1742
2272
 
1743
2273
 
1744
2274
class BzrDirFormat4(BzrDirFormat):
2156
2686
"""
2157
2687
 
2158
2688
 
 
2689
# Register bzr control format
 
2690
BzrDirFormat.register_control_format(BzrDirFormat)
 
2691
 
2159
2692
# Register bzr formats
2160
2693
BzrDirFormat.register_format(BzrDirFormat4())
2161
2694
BzrDirFormat.register_format(BzrDirFormat5())
2162
2695
BzrDirFormat.register_format(BzrDirFormat6())
2163
2696
__default_format = BzrDirMetaFormat1()
2164
2697
BzrDirFormat.register_format(__default_format)
2165
 
controldir.ControlDirFormat._default_format = __default_format
 
2698
BzrDirFormat._default_format = __default_format
2166
2699
 
2167
2700
 
2168
2701
class Converter(object):
2330
2863
            self.revisions[rev_id] = rev
2331
2864
 
2332
2865
    def _load_old_inventory(self, rev_id):
2333
 
        f = self.branch.repository.inventory_store.get(rev_id)
2334
 
        try:
2335
 
            old_inv_xml = f.read()
2336
 
        finally:
2337
 
            f.close()
 
2866
        old_inv_xml = self.branch.repository.inventory_store.get(rev_id).read()
2338
2867
        inv = xml4.serializer_v4.read_inventory_from_string(old_inv_xml)
2339
2868
        inv.revision_id = rev_id
2340
2869
        rev = self.revisions[rev_id]
2396
2925
        previous_entries = dict((head, parent_candiate_entries[head]) for head
2397
2926
            in heads)
2398
2927
        self.snapshot_ie(previous_entries, ie, w, rev_id)
 
2928
        del ie.text_id
2399
2929
 
2400
2930
    def get_parent_map(self, revision_ids):
2401
2931
        """See graph.StackedParentsProvider.get_parent_map"""
2417
2947
                ie.revision = previous_ie.revision
2418
2948
                return
2419
2949
        if ie.has_text():
2420
 
            f = self.branch.repository._text_store.get(ie.text_id)
2421
 
            try:
2422
 
                file_lines = f.readlines()
2423
 
            finally:
2424
 
                f.close()
 
2950
            text = self.branch.repository._text_store.get(ie.text_id)
 
2951
            file_lines = text.readlines()
2425
2952
            w.add_lines(rev_id, previous_revisions, file_lines)
2426
2953
            self.text_count += 1
2427
2954
        else:
2708
3235
        # XXX: It's a bit ugly that the network name is here, because we'd
2709
3236
        # like to believe that format objects are stateless or at least
2710
3237
        # immutable,  However, we do at least avoid mutating the name after
2711
 
        # it's returned.  See <https://bugs.launchpad.net/bzr/+bug/504102>
 
3238
        # it's returned.  See <https://bugs.edge.launchpad.net/bzr/+bug/504102>
2712
3239
        self._network_name = None
2713
3240
 
2714
3241
    def __repr__(self):
2730
3257
        else:
2731
3258
            raise AssertionError("No network name set.")
2732
3259
 
 
3260
    @classmethod
 
3261
    def probe_transport(klass, transport):
 
3262
        """Return a RemoteBzrDirFormat object if it looks possible."""
 
3263
        try:
 
3264
            medium = transport.get_smart_medium()
 
3265
        except (NotImplementedError, AttributeError,
 
3266
                errors.TransportNotPossible, errors.NoSmartMedium,
 
3267
                errors.SmartProtocolError):
 
3268
            # no smart server, so not a branch for this format type.
 
3269
            raise errors.NotBranchError(path=transport.base)
 
3270
        else:
 
3271
            # Decline to open it if the server doesn't support our required
 
3272
            # version (3) so that the VFS-based transport will do it.
 
3273
            if medium.should_probe():
 
3274
                try:
 
3275
                    server_version = medium.protocol_version()
 
3276
                except errors.SmartProtocolError:
 
3277
                    # Apparently there's no usable smart server there, even though
 
3278
                    # the medium supports the smart protocol.
 
3279
                    raise errors.NotBranchError(path=transport.base)
 
3280
                if server_version != '2':
 
3281
                    raise errors.NotBranchError(path=transport.base)
 
3282
            return klass()
 
3283
 
2733
3284
    def initialize_on_transport(self, transport):
2734
3285
        try:
2735
3286
            # hand off the request to the smart server
2934
3485
        BzrDirMetaFormat1._set_repository_format) #.im_func)
2935
3486
 
2936
3487
 
2937
 
controldir.ControlDirFormat.register_server_prober(RemoteBzrProber)
 
3488
BzrDirFormat.register_control_server_format(RemoteBzrDirFormat)
 
3489
 
 
3490
 
 
3491
class BzrDirFormatInfo(object):
 
3492
 
 
3493
    def __init__(self, native, deprecated, hidden, experimental):
 
3494
        self.deprecated = deprecated
 
3495
        self.native = native
 
3496
        self.hidden = hidden
 
3497
        self.experimental = experimental
 
3498
 
 
3499
 
 
3500
class BzrDirFormatRegistry(registry.Registry):
 
3501
    """Registry of user-selectable BzrDir subformats.
 
3502
 
 
3503
    Differs from BzrDirFormat._control_formats in that it provides sub-formats,
 
3504
    e.g. BzrDirMeta1 with weave repository.  Also, it's more user-oriented.
 
3505
    """
 
3506
 
 
3507
    def __init__(self):
 
3508
        """Create a BzrDirFormatRegistry."""
 
3509
        self._aliases = set()
 
3510
        self._registration_order = list()
 
3511
        super(BzrDirFormatRegistry, self).__init__()
 
3512
 
 
3513
    def aliases(self):
 
3514
        """Return a set of the format names which are aliases."""
 
3515
        return frozenset(self._aliases)
 
3516
 
 
3517
    def register_metadir(self, key,
 
3518
             repository_format, help, native=True, deprecated=False,
 
3519
             branch_format=None,
 
3520
             tree_format=None,
 
3521
             hidden=False,
 
3522
             experimental=False,
 
3523
             alias=False):
 
3524
        """Register a metadir subformat.
 
3525
 
 
3526
        These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
 
3527
        by the Repository/Branch/WorkingTreeformats.
 
3528
 
 
3529
        :param repository_format: The fully-qualified repository format class
 
3530
            name as a string.
 
3531
        :param branch_format: Fully-qualified branch format class name as
 
3532
            a string.
 
3533
        :param tree_format: Fully-qualified tree format class name as
 
3534
            a string.
 
3535
        """
 
3536
        # This should be expanded to support setting WorkingTree and Branch
 
3537
        # formats, once BzrDirMetaFormat1 supports that.
 
3538
        def _load(full_name):
 
3539
            mod_name, factory_name = full_name.rsplit('.', 1)
 
3540
            try:
 
3541
                mod = __import__(mod_name, globals(), locals(),
 
3542
                        [factory_name])
 
3543
            except ImportError, e:
 
3544
                raise ImportError('failed to load %s: %s' % (full_name, e))
 
3545
            try:
 
3546
                factory = getattr(mod, factory_name)
 
3547
            except AttributeError:
 
3548
                raise AttributeError('no factory %s in module %r'
 
3549
                    % (full_name, mod))
 
3550
            return factory()
 
3551
 
 
3552
        def helper():
 
3553
            bd = BzrDirMetaFormat1()
 
3554
            if branch_format is not None:
 
3555
                bd.set_branch_format(_load(branch_format))
 
3556
            if tree_format is not None:
 
3557
                bd.workingtree_format = _load(tree_format)
 
3558
            if repository_format is not None:
 
3559
                bd.repository_format = _load(repository_format)
 
3560
            return bd
 
3561
        self.register(key, helper, help, native, deprecated, hidden,
 
3562
            experimental, alias)
 
3563
 
 
3564
    def register(self, key, factory, help, native=True, deprecated=False,
 
3565
                 hidden=False, experimental=False, alias=False):
 
3566
        """Register a BzrDirFormat factory.
 
3567
 
 
3568
        The factory must be a callable that takes one parameter: the key.
 
3569
        It must produce an instance of the BzrDirFormat when called.
 
3570
 
 
3571
        This function mainly exists to prevent the info object from being
 
3572
        supplied directly.
 
3573
        """
 
3574
        registry.Registry.register(self, key, factory, help,
 
3575
            BzrDirFormatInfo(native, deprecated, hidden, experimental))
 
3576
        if alias:
 
3577
            self._aliases.add(key)
 
3578
        self._registration_order.append(key)
 
3579
 
 
3580
    def register_lazy(self, key, module_name, member_name, help, native=True,
 
3581
        deprecated=False, hidden=False, experimental=False, alias=False):
 
3582
        registry.Registry.register_lazy(self, key, module_name, member_name,
 
3583
            help, BzrDirFormatInfo(native, deprecated, hidden, experimental))
 
3584
        if alias:
 
3585
            self._aliases.add(key)
 
3586
        self._registration_order.append(key)
 
3587
 
 
3588
    def set_default(self, key):
 
3589
        """Set the 'default' key to be a clone of the supplied key.
 
3590
 
 
3591
        This method must be called once and only once.
 
3592
        """
 
3593
        registry.Registry.register(self, 'default', self.get(key),
 
3594
            self.get_help(key), info=self.get_info(key))
 
3595
        self._aliases.add('default')
 
3596
 
 
3597
    def set_default_repository(self, key):
 
3598
        """Set the FormatRegistry default and Repository default.
 
3599
 
 
3600
        This is a transitional method while Repository.set_default_format
 
3601
        is deprecated.
 
3602
        """
 
3603
        if 'default' in self:
 
3604
            self.remove('default')
 
3605
        self.set_default(key)
 
3606
        format = self.get('default')()
 
3607
 
 
3608
    def make_bzrdir(self, key):
 
3609
        return self.get(key)()
 
3610
 
 
3611
    def help_topic(self, topic):
 
3612
        output = ""
 
3613
        default_realkey = None
 
3614
        default_help = self.get_help('default')
 
3615
        help_pairs = []
 
3616
        for key in self._registration_order:
 
3617
            if key == 'default':
 
3618
                continue
 
3619
            help = self.get_help(key)
 
3620
            if help == default_help:
 
3621
                default_realkey = key
 
3622
            else:
 
3623
                help_pairs.append((key, help))
 
3624
 
 
3625
        def wrapped(key, help, info):
 
3626
            if info.native:
 
3627
                help = '(native) ' + help
 
3628
            return ':%s:\n%s\n\n' % (key,
 
3629
                textwrap.fill(help, initial_indent='    ',
 
3630
                    subsequent_indent='    ',
 
3631
                    break_long_words=False))
 
3632
        if default_realkey is not None:
 
3633
            output += wrapped(default_realkey, '(default) %s' % default_help,
 
3634
                              self.get_info('default'))
 
3635
        deprecated_pairs = []
 
3636
        experimental_pairs = []
 
3637
        for key, help in help_pairs:
 
3638
            info = self.get_info(key)
 
3639
            if info.hidden:
 
3640
                continue
 
3641
            elif info.deprecated:
 
3642
                deprecated_pairs.append((key, help))
 
3643
            elif info.experimental:
 
3644
                experimental_pairs.append((key, help))
 
3645
            else:
 
3646
                output += wrapped(key, help, info)
 
3647
        output += "\nSee :doc:`formats-help` for more about storage formats."
 
3648
        other_output = ""
 
3649
        if len(experimental_pairs) > 0:
 
3650
            other_output += "Experimental formats are shown below.\n\n"
 
3651
            for key, help in experimental_pairs:
 
3652
                info = self.get_info(key)
 
3653
                other_output += wrapped(key, help, info)
 
3654
        else:
 
3655
            other_output += \
 
3656
                "No experimental formats are available.\n\n"
 
3657
        if len(deprecated_pairs) > 0:
 
3658
            other_output += "\nDeprecated formats are shown below.\n\n"
 
3659
            for key, help in deprecated_pairs:
 
3660
                info = self.get_info(key)
 
3661
                other_output += wrapped(key, help, info)
 
3662
        else:
 
3663
            other_output += \
 
3664
                "\nNo deprecated formats are available.\n\n"
 
3665
        other_output += \
 
3666
                "\nSee :doc:`formats-help` for more about storage formats."
 
3667
 
 
3668
        if topic == 'other-formats':
 
3669
            return other_output
 
3670
        else:
 
3671
            return output
2938
3672
 
2939
3673
 
2940
3674
class RepositoryAcquisitionPolicy(object):
3094
3828
        return self._repository, False
3095
3829
 
3096
3830
 
3097
 
def register_metadir(registry, key,
3098
 
         repository_format, help, native=True, deprecated=False,
3099
 
         branch_format=None,
3100
 
         tree_format=None,
3101
 
         hidden=False,
3102
 
         experimental=False,
3103
 
         alias=False):
3104
 
    """Register a metadir subformat.
3105
 
 
3106
 
    These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
3107
 
    by the Repository/Branch/WorkingTreeformats.
3108
 
 
3109
 
    :param repository_format: The fully-qualified repository format class
3110
 
        name as a string.
3111
 
    :param branch_format: Fully-qualified branch format class name as
3112
 
        a string.
3113
 
    :param tree_format: Fully-qualified tree format class name as
3114
 
        a string.
3115
 
    """
3116
 
    # This should be expanded to support setting WorkingTree and Branch
3117
 
    # formats, once BzrDirMetaFormat1 supports that.
3118
 
    def _load(full_name):
3119
 
        mod_name, factory_name = full_name.rsplit('.', 1)
3120
 
        try:
3121
 
            mod = __import__(mod_name, globals(), locals(),
3122
 
                    [factory_name])
3123
 
        except ImportError, e:
3124
 
            raise ImportError('failed to load %s: %s' % (full_name, e))
3125
 
        try:
3126
 
            factory = getattr(mod, factory_name)
3127
 
        except AttributeError:
3128
 
            raise AttributeError('no factory %s in module %r'
3129
 
                % (full_name, mod))
3130
 
        return factory()
3131
 
 
3132
 
    def helper():
3133
 
        bd = BzrDirMetaFormat1()
3134
 
        if branch_format is not None:
3135
 
            bd.set_branch_format(_load(branch_format))
3136
 
        if tree_format is not None:
3137
 
            bd.workingtree_format = _load(tree_format)
3138
 
        if repository_format is not None:
3139
 
            bd.repository_format = _load(repository_format)
3140
 
        return bd
3141
 
    registry.register(key, helper, help, native, deprecated, hidden,
3142
 
        experimental, alias)
3143
 
 
 
3831
# Please register new formats after old formats so that formats
 
3832
# appear in chronological order and format descriptions can build
 
3833
# on previous ones.
 
3834
format_registry = BzrDirFormatRegistry()
3144
3835
# The pre-0.8 formats have their repository format network name registered in
3145
3836
# repository.py. MetaDir formats have their repository format network name
3146
3837
# inferred from their disk format string.
3147
 
controldir.format_registry.register('weave', BzrDirFormat6,
 
3838
format_registry.register('weave', BzrDirFormat6,
3148
3839
    'Pre-0.8 format.  Slower than knit and does not'
3149
3840
    ' support checkouts or shared repositories.',
3150
3841
    hidden=True,
3151
3842
    deprecated=True)
3152
 
register_metadir(controldir.format_registry, 'metaweave',
 
3843
format_registry.register_metadir('metaweave',
3153
3844
    'bzrlib.repofmt.weaverepo.RepositoryFormat7',
3154
3845
    'Transitional format in 0.8.  Slower than knit.',
3155
3846
    branch_format='bzrlib.branch.BzrBranchFormat5',
3156
3847
    tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3157
3848
    hidden=True,
3158
3849
    deprecated=True)
3159
 
register_metadir(controldir.format_registry, 'knit',
 
3850
format_registry.register_metadir('knit',
3160
3851
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3161
3852
    'Format using knits.  Recommended for interoperation with bzr <= 0.14.',
3162
3853
    branch_format='bzrlib.branch.BzrBranchFormat5',
3163
3854
    tree_format='bzrlib.workingtree.WorkingTreeFormat3',
3164
3855
    hidden=True,
3165
3856
    deprecated=True)
3166
 
register_metadir(controldir.format_registry, 'dirstate',
 
3857
format_registry.register_metadir('dirstate',
3167
3858
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3168
3859
    help='New in 0.15: Fast local operations. Compatible with bzr 0.8 and '
3169
3860
        'above when accessed over the network.',
3173
3864
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3174
3865
    hidden=True,
3175
3866
    deprecated=True)
3176
 
register_metadir(controldir.format_registry, 'dirstate-tags',
 
3867
format_registry.register_metadir('dirstate-tags',
3177
3868
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3178
3869
    help='New in 0.15: Fast local operations and improved scaling for '
3179
3870
        'network operations. Additionally adds support for tags.'
3182
3873
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3183
3874
    hidden=True,
3184
3875
    deprecated=True)
3185
 
register_metadir(controldir.format_registry, 'rich-root',
 
3876
format_registry.register_metadir('rich-root',
3186
3877
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit4',
3187
3878
    help='New in 1.0.  Better handling of tree roots.  Incompatible with'
3188
3879
        ' bzr < 1.0.',
3190
3881
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3191
3882
    hidden=True,
3192
3883
    deprecated=True)
3193
 
register_metadir(controldir.format_registry, 'dirstate-with-subtree',
 
3884
format_registry.register_metadir('dirstate-with-subtree',
3194
3885
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
3195
3886
    help='New in 0.15: Fast local operations and improved scaling for '
3196
3887
        'network operations. Additionally adds support for versioning nested '
3200
3891
    experimental=True,
3201
3892
    hidden=True,
3202
3893
    )
3203
 
register_metadir(controldir.format_registry, 'pack-0.92',
 
3894
format_registry.register_metadir('pack-0.92',
3204
3895
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack1',
3205
3896
    help='New in 0.92: Pack-based format with data compatible with '
3206
3897
        'dirstate-tags format repositories. Interoperates with '
3209
3900
    branch_format='bzrlib.branch.BzrBranchFormat6',
3210
3901
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3211
3902
    )
3212
 
register_metadir(controldir.format_registry, 'pack-0.92-subtree',
 
3903
format_registry.register_metadir('pack-0.92-subtree',
3213
3904
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack3',
3214
3905
    help='New in 0.92: Pack-based format with data compatible with '
3215
3906
        'dirstate-with-subtree format repositories. Interoperates with '
3220
3911
    hidden=True,
3221
3912
    experimental=True,
3222
3913
    )
3223
 
register_metadir(controldir.format_registry, 'rich-root-pack',
 
3914
format_registry.register_metadir('rich-root-pack',
3224
3915
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack4',
3225
3916
    help='New in 1.0: A variant of pack-0.92 that supports rich-root data '
3226
3917
         '(needed for bzr-svn and bzr-git).',
3228
3919
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3229
3920
    hidden=True,
3230
3921
    )
3231
 
register_metadir(controldir.format_registry, '1.6',
 
3922
format_registry.register_metadir('1.6',
3232
3923
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5',
3233
3924
    help='A format that allows a branch to indicate that there is another '
3234
3925
         '(stacked) repository that should be used to access data that is '
3237
3928
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3238
3929
    hidden=True,
3239
3930
    )
3240
 
register_metadir(controldir.format_registry, '1.6.1-rich-root',
 
3931
format_registry.register_metadir('1.6.1-rich-root',
3241
3932
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5RichRoot',
3242
3933
    help='A variant of 1.6 that supports rich-root data '
3243
3934
         '(needed for bzr-svn and bzr-git).',
3245
3936
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3246
3937
    hidden=True,
3247
3938
    )
3248
 
register_metadir(controldir.format_registry, '1.9',
 
3939
format_registry.register_metadir('1.9',
3249
3940
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3250
3941
    help='A repository format using B+tree indexes. These indexes '
3251
3942
         'are smaller in size, have smarter caching and provide faster '
3254
3945
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3255
3946
    hidden=True,
3256
3947
    )
3257
 
register_metadir(controldir.format_registry, '1.9-rich-root',
 
3948
format_registry.register_metadir('1.9-rich-root',
3258
3949
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3259
3950
    help='A variant of 1.9 that supports rich-root data '
3260
3951
         '(needed for bzr-svn and bzr-git).',
3262
3953
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3263
3954
    hidden=True,
3264
3955
    )
3265
 
register_metadir(controldir.format_registry, '1.14',
 
3956
format_registry.register_metadir('1.14',
3266
3957
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3267
3958
    help='A working-tree format that supports content filtering.',
3268
3959
    branch_format='bzrlib.branch.BzrBranchFormat7',
3269
3960
    tree_format='bzrlib.workingtree.WorkingTreeFormat5',
3270
3961
    )
3271
 
register_metadir(controldir.format_registry, '1.14-rich-root',
 
3962
format_registry.register_metadir('1.14-rich-root',
3272
3963
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3273
3964
    help='A variant of 1.14 that supports rich-root data '
3274
3965
         '(needed for bzr-svn and bzr-git).',
3276
3967
    tree_format='bzrlib.workingtree.WorkingTreeFormat5',
3277
3968
    )
3278
3969
# The following un-numbered 'development' formats should always just be aliases.
3279
 
register_metadir(controldir.format_registry, 'development-rich-root',
 
3970
format_registry.register_metadir('development-rich-root',
3280
3971
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK1',
3281
3972
    help='Current development format. Supports rich roots. Can convert data '
3282
3973
        'to and from rich-root-pack (and anything compatible with '
3290
3981
    alias=True,
3291
3982
    hidden=True,
3292
3983
    )
3293
 
register_metadir(controldir.format_registry, 'development5-subtree',
 
3984
format_registry.register_metadir('development-subtree',
3294
3985
    'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
3295
 
    help='Development format, subtree variant. Can convert data to and '
3296
 
        'from pack-0.92-subtree (and anything compatible with '
3297
 
        'pack-0.92-subtree) format repositories. Repositories and branches in '
3298
 
        'this format can only be read by bzr.dev. Please read '
3299
 
        'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3300
 
        'before use.',
3301
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3302
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3303
 
    experimental=True,
3304
 
    hidden=True,
3305
 
    alias=False,
3306
 
    )
3307
 
 
3308
 
 
3309
 
register_metadir(controldir.format_registry, 'development-subtree',
3310
 
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2aSubtree',
3311
3986
    help='Current development format, subtree variant. Can convert data to and '
3312
3987
        'from pack-0.92-subtree (and anything compatible with '
3313
3988
        'pack-0.92-subtree) format repositories. Repositories and branches in '
3324
3999
    )
3325
4000
 
3326
4001
# And the development formats above will have aliased one of the following:
3327
 
register_metadir(controldir.format_registry, 'development6-rich-root',
 
4002
format_registry.register_metadir('development6-rich-root',
3328
4003
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK1',
3329
4004
    help='pack-1.9 with 255-way hashed CHK inv, group compress, rich roots '
3330
4005
        'Please read '
3336
4011
    experimental=True,
3337
4012
    )
3338
4013
 
3339
 
register_metadir(controldir.format_registry, 'development7-rich-root',
 
4014
format_registry.register_metadir('development7-rich-root',
3340
4015
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK2',
3341
4016
    help='pack-1.9 with 255-way hashed CHK inv, bencode revision, group compress, '
3342
4017
        'rich roots. Please read '
3348
4023
    experimental=True,
3349
4024
    )
3350
4025
 
3351
 
register_metadir(controldir.format_registry, '2a',
 
4026
format_registry.register_metadir('2a',
3352
4027
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
3353
4028
    help='First format for bzr 2.0 series.\n'
3354
4029
        'Uses group-compress storage.\n'
3357
4032
        # 'rich roots. Supported by bzr 1.16 and later.',
3358
4033
    branch_format='bzrlib.branch.BzrBranchFormat7',
3359
4034
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3360
 
    experimental=False,
 
4035
    experimental=True,
3361
4036
    )
3362
4037
 
3363
4038
# The following format should be an alias for the rich root equivalent 
3364
4039
# of the default format
3365
 
register_metadir(controldir.format_registry, 'default-rich-root',
 
4040
format_registry.register_metadir('default-rich-root',
3366
4041
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
3367
4042
    branch_format='bzrlib.branch.BzrBranchFormat7',
3368
4043
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3371
4046
    help='Same as 2a.')
3372
4047
 
3373
4048
# The current format that is made on 'bzr init'.
3374
 
controldir.format_registry.set_default('2a')
3375
 
 
3376
 
# XXX 2010-08-20 JRV: There is still a lot of code relying on
3377
 
# bzrlib.bzrdir.format_registry existing. When BzrDir.create/BzrDir.open/etc
3378
 
# get changed to ControlDir.create/ControlDir.open/etc this should be removed.
3379
 
format_registry = controldir.format_registry
 
4049
format_registry.set_default('2a')