← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bzrdir.py

  • Committer: Mark Hammond
  • Date: 2009-01-12 01:55:34 UTC
  • mto: (3995.8.2 prepare-1.12)
  • mto: This revision was merged to the branch mainline in revision 4007.
  • Revision ID: mhammond@skippinet.com.au-20090112015534-yfxg50p7mpds9j4v
Include all .html files from the tortoise doc directory.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bzrdir.py
1
 
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""BzrDir logic. The BzrDir is the basic control directory used by bzr.
18
18
 
37
37
 
38
38
import bzrlib
39
39
from bzrlib import (
40
 
    branch,
41
40
    config,
42
41
    errors,
43
42
    graph,
45
44
    lockdir,
46
45
    osutils,
47
46
    remote,
48
 
    repository,
49
47
    revision as _mod_revision,
50
48
    ui,
51
49
    urlutils,
59
57
from bzrlib.osutils import (
60
58
    sha_string,
61
59
    )
62
 
from bzrlib.push import (
63
 
    PushResult,
64
 
    )
65
 
from bzrlib.repofmt import pack_repo
66
60
from bzrlib.smart.client import _SmartClient
67
61
from bzrlib.store.versioned import WeaveStore
68
62
from bzrlib.transactions import WriteTransaction
80
74
    )
81
75
 
82
76
from bzrlib import (
83
 
    hooks,
84
77
    registry,
85
78
    symbol_versioning,
86
79
    )
88
81
 
89
82
class BzrDir(object):
90
83
    """A .bzr control diretory.
91
 
 
 
84
    
92
85
    BzrDir instances let you create or open any of the things that can be
93
86
    found within .bzr - checkouts, branches and repositories.
94
 
 
 
87
    
95
88
    :ivar transport:
96
89
        the transport which this bzr dir is rooted at (i.e. file:///.../.bzr/)
97
90
    :ivar root_transport:
99
92
        (i.e. the parent directory holding the .bzr directory).
100
93
 
101
94
    Everything in the bzrdir should have the same file permissions.
102
 
 
103
 
    :cvar hooks: An instance of BzrDirHooks.
104
95
    """
105
96
 
106
97
    def break_lock(self):
138
129
        basedir=None):
139
130
        """Give an error or warning on old formats.
140
131
 
141
 
        :param format: may be any kind of format - workingtree, branch,
 
132
        :param format: may be any kind of format - workingtree, branch, 
142
133
        or repository.
143
134
 
144
 
        :param allow_unsupported: If true, allow opening
145
 
        formats that are strongly deprecated, and which may
 
135
        :param allow_unsupported: If true, allow opening 
 
136
        formats that are strongly deprecated, and which may 
146
137
        have limited functionality.
147
138
 
148
139
        :param recommend_upgrade: If true (default), warn
180
171
                                       preserve_stacking=preserve_stacking)
181
172
 
182
173
    def clone_on_transport(self, transport, revision_id=None,
183
 
        force_new_repo=False, preserve_stacking=False, stacked_on=None,
184
 
        create_prefix=False, use_existing_dir=True):
 
174
                           force_new_repo=False, preserve_stacking=False,
 
175
                           stacked_on=None):
185
176
        """Clone this bzrdir and its contents to transport verbatim.
186
177
 
187
178
        :param transport: The transport for the location to produce the clone
193
184
                               even if one is available.
194
185
        :param preserve_stacking: When cloning a stacked branch, stack the
195
186
            new branch on top of the other branch's stacked-on branch.
196
 
        :param create_prefix: Create any missing directories leading up to
197
 
            to_transport.
198
 
        :param use_existing_dir: Use an existing directory if one exists.
199
187
        """
200
 
        # Overview: put together a broad description of what we want to end up
201
 
        # with; then make as few api calls as possible to do it.
202
 
        
203
 
        # We may want to create a repo/branch/tree, if we do so what format
204
 
        # would we want for each:
 
188
        transport.ensure_base()
205
189
        require_stacking = (stacked_on is not None)
206
 
        format = self.cloning_metadir(require_stacking)
207
 
        
208
 
        # Figure out what objects we want:
 
190
        metadir = self.cloning_metadir(require_stacking)
 
191
        result = metadir.initialize_on_transport(transport)
 
192
        repository_policy = None
209
193
        try:
210
194
            local_repo = self.find_repository()
211
195
        except errors.NoRepositoryPresent:
225
209
                        errors.UnstackableRepositoryFormat,
226
210
                        errors.NotStacked):
227
211
                    pass
228
 
        # Bug: We create a metadir without knowing if it can support stacking,
229
 
        # we should look up the policy needs first, or just use it as a hint,
230
 
        # or something.
 
212
 
231
213
        if local_repo:
 
214
            # may need to copy content in
 
215
            repository_policy = result.determine_repository_policy(
 
216
                force_new_repo, stacked_on, self.root_transport.base,
 
217
                require_stacking=require_stacking)
232
218
            make_working_trees = local_repo.make_working_trees()
233
 
            want_shared = local_repo.is_shared()
234
 
            repo_format_name = format.repository_format.network_name()
235
 
        else:
236
 
            make_working_trees = False
237
 
            want_shared = False
238
 
            repo_format_name = None
239
 
 
240
 
        result_repo, result, require_stacking, repository_policy = \
241
 
            format.initialize_on_transport_ex(transport,
242
 
            use_existing_dir=use_existing_dir, create_prefix=create_prefix,
243
 
            force_new_repo=force_new_repo, stacked_on=stacked_on,
244
 
            stack_on_pwd=self.root_transport.base,
245
 
            repo_format_name=repo_format_name,
246
 
            make_working_trees=make_working_trees, shared_repo=want_shared)
247
 
        if repo_format_name:
248
 
            try:
249
 
                # If the result repository is in the same place as the
250
 
                # resulting bzr dir, it will have no content, further if the
251
 
                # result is not stacked then we know all content should be
252
 
                # copied, and finally if we are copying up to a specific
253
 
                # revision_id then we can use the pending-ancestry-result which
254
 
                # does not require traversing all of history to describe it.
255
 
                if (result_repo.bzrdir.root_transport.base ==
256
 
                    result.root_transport.base and not require_stacking and
257
 
                    revision_id is not None):
258
 
                    fetch_spec = graph.PendingAncestryResult(
259
 
                        [revision_id], local_repo)
260
 
                    result_repo.fetch(local_repo, fetch_spec=fetch_spec)
261
 
                else:
262
 
                    result_repo.fetch(local_repo, revision_id=revision_id)
263
 
            finally:
264
 
                result_repo.unlock()
265
 
        else:
266
 
            if result_repo is not None:
267
 
                raise AssertionError('result_repo not None(%r)' % result_repo)
 
219
            result_repo = repository_policy.acquire_repository(
 
220
                make_working_trees, local_repo.is_shared())
 
221
            if not require_stacking and repository_policy._require_stacking:
 
222
                require_stacking = True
 
223
                result._format.require_stacking()
 
224
            result_repo.fetch(local_repo, revision_id=revision_id)
 
225
        else:
 
226
            result_repo = None
268
227
        # 1 if there is a branch present
269
228
        #   make sure its content is available in the target repository
270
229
        #   clone it.
271
230
        if local_branch is not None:
272
 
            result_branch = local_branch.clone(result, revision_id=revision_id,
273
 
                repository_policy=repository_policy)
274
 
        try:
275
 
            # Cheaper to check if the target is not local, than to try making
276
 
            # the tree and fail.
277
 
            result.root_transport.local_abspath('.')
278
 
            if result_repo is None or result_repo.make_working_trees():
 
231
            result_branch = local_branch.clone(result, revision_id=revision_id)
 
232
            if repository_policy is not None:
 
233
                repository_policy.configure_branch(result_branch)
 
234
        if result_repo is None or result_repo.make_working_trees():
 
235
            try:
279
236
                self.open_workingtree().clone(result)
280
 
        except (errors.NoWorkingTree, errors.NotLocalUrl):
281
 
            pass
 
237
            except (errors.NoWorkingTree, errors.NotLocalUrl):
 
238
                pass
282
239
        return result
283
240
 
284
241
    # TODO: This should be given a Transport, and should chdir up; otherwise
290
247
    @classmethod
291
248
    def create(cls, base, format=None, possible_transports=None):
292
249
        """Create a new BzrDir at the url 'base'.
293
 
 
 
250
        
294
251
        :param format: If supplied, the format of branch to create.  If not
295
252
            supplied, the default is used.
296
 
        :param possible_transports: If supplied, a list of transports that
 
253
        :param possible_transports: If supplied, a list of transports that 
297
254
            can be reused to share a remote connection.
298
255
        """
299
256
        if cls is not BzrDir:
399
356
        """Create a new BzrDir, Branch and Repository at the url 'base'.
400
357
 
401
358
        This will use the current default BzrDirFormat unless one is
402
 
        specified, and use whatever
 
359
        specified, and use whatever 
403
360
        repository format that that uses via bzrdir.create_branch and
404
361
        create_repository. If a shared repository is available that is used
405
362
        preferentially.
419
376
                                    stack_on_pwd=None, require_stacking=False):
420
377
        """Return an object representing a policy to use.
421
378
 
422
 
        This controls whether a new repository is created, and the format of
423
 
        that repository, or some existing shared repository used instead.
 
379
        This controls whether a new repository is created, or a shared
 
380
        repository used instead.
424
381
 
425
382
        If stack_on is supplied, will not seek a containing shared repo.
426
383
 
435
392
            stack_on_pwd = None
436
393
            config = found_bzrdir.get_config()
437
394
            stop = False
438
 
            stack_on = config.get_default_stack_on()
439
 
            if stack_on is not None:
440
 
                stack_on_pwd = found_bzrdir.root_transport.base
441
 
                stop = True
 
395
            if config is not None:
 
396
                stack_on = config.get_default_stack_on()
 
397
                if stack_on is not None:
 
398
                    stack_on_pwd = found_bzrdir.root_transport.base
 
399
                    stop = True
 
400
                    note('Using default stacking branch %s at %s', stack_on,
 
401
                         stack_on_pwd)
442
402
            # does it have a repository ?
443
403
            try:
444
404
                repository = found_bzrdir.open_repository()
447
407
            else:
448
408
                if ((found_bzrdir.root_transport.base !=
449
409
                     self.root_transport.base) and not repository.is_shared()):
450
 
                    # Don't look higher, can't use a higher shared repo.
451
410
                    repository = None
452
 
                    stop = True
453
411
                else:
454
412
                    stop = True
455
413
            if not stop:
479
437
    def _find_or_create_repository(self, force_new_repo):
480
438
        """Create a new repository if needed, returning the repository."""
481
439
        policy = self.determine_repository_policy(force_new_repo)
482
 
        return policy.acquire_repository()[0]
 
440
        return policy.acquire_repository()
483
441
 
484
442
    @staticmethod
485
443
    def create_branch_convenience(base, force_new_repo=False,
492
450
        not.
493
451
 
494
452
        This will use the current default BzrDirFormat unless one is
495
 
        specified, and use whatever
 
453
        specified, and use whatever 
496
454
        repository format that that uses via bzrdir.create_branch and
497
455
        create_repository. If a shared repository is available that is used
498
456
        preferentially. Whatever repository is used, its tree creation policy
500
458
 
501
459
        The created Branch object is returned.
502
460
        If a working tree cannot be made due to base not being a file:// url,
503
 
        no error is raised unless force_new_tree is True, in which case no
 
461
        no error is raised unless force_new_tree is True, in which case no 
504
462
        data is created on disk and NotLocalUrl is raised.
505
463
 
506
464
        :param base: The URL to create the branch at.
507
465
        :param force_new_repo: If True a new repository is always created.
508
 
        :param force_new_tree: If True or False force creation of a tree or
 
466
        :param force_new_tree: If True or False force creation of a tree or 
509
467
                               prevent such creation respectively.
510
468
        :param format: Override for the bzrdir format to create.
511
469
        :param possible_transports: An optional reusable transports list.
533
491
        'base' must be a local path or a file:// url.
534
492
 
535
493
        This will use the current default BzrDirFormat unless one is
536
 
        specified, and use whatever
 
494
        specified, and use whatever 
537
495
        repository format that that uses for bzrdirformat.create_workingtree,
538
496
        create_branch and create_repository.
539
497
 
551
509
    def create_workingtree(self, revision_id=None, from_branch=None,
552
510
        accelerator_tree=None, hardlink=False):
553
511
        """Create a working tree at this BzrDir.
554
 
 
 
512
        
555
513
        :param revision_id: create it as of this revision id.
556
514
        :param from_branch: override bzrdir branch (for lightweight checkouts)
557
515
        :param accelerator_tree: A tree which can be used for retrieving file
563
521
 
564
522
    def backup_bzrdir(self):
565
523
        """Backup this bzr control directory.
566
 
 
 
524
        
567
525
        :return: Tuple with old path name and new path name
568
526
        """
569
 
        pb = ui.ui_factory.nested_progress_bar()
570
 
        try:
571
 
            # FIXME: bug 300001 -- the backup fails if the backup directory
572
 
            # already exists, but it should instead either remove it or make
573
 
            # a new backup directory.
574
 
            #
575
 
            # FIXME: bug 262450 -- the backup directory should have the same
576
 
            # permissions as the .bzr directory (probably a bug in copy_tree)
577
 
            old_path = self.root_transport.abspath('.bzr')
578
 
            new_path = self.root_transport.abspath('backup.bzr')
579
 
            pb.note('making backup of %s' % (old_path,))
580
 
            pb.note('  to %s' % (new_path,))
581
 
            self.root_transport.copy_tree('.bzr', 'backup.bzr')
582
 
            return (old_path, new_path)
583
 
        finally:
584
 
            pb.finished()
 
527
        self.root_transport.copy_tree('.bzr', 'backup.bzr')
 
528
        return (self.root_transport.abspath('.bzr'),
 
529
                self.root_transport.abspath('backup.bzr'))
585
530
 
586
531
    def retire_bzrdir(self, limit=10000):
587
532
        """Permanently disable the bzrdir.
693
638
        IncompatibleFormat if the branch format they are given has
694
639
        a format string, and vice versa.
695
640
 
696
 
        If branch_format is None, the transport is returned with no
 
641
        If branch_format is None, the transport is returned with no 
697
642
        checking. If it is not None, then the returned transport is
698
643
        guaranteed to point to an existing directory ready for use.
699
644
        """
742
687
        if not self._mode_check_done:
743
688
            self._find_creation_modes()
744
689
        return self._dir_mode
745
 
 
 
690
        
746
691
    def get_repository_transport(self, repository_format):
747
692
        """Get the transport for use by repository format in this BzrDir.
748
693
 
750
695
        IncompatibleFormat if the repository format they are given has
751
696
        a format string, and vice versa.
752
697
 
753
 
        If repository_format is None, the transport is returned with no
 
698
        If repository_format is None, the transport is returned with no 
754
699
        checking. If it is not None, then the returned transport is
755
700
        guaranteed to point to an existing directory ready for use.
756
701
        """
757
702
        raise NotImplementedError(self.get_repository_transport)
758
 
 
 
703
        
759
704
    def get_workingtree_transport(self, tree_format):
760
705
        """Get the transport for use by workingtree format in this BzrDir.
761
706
 
763
708
        IncompatibleFormat if the workingtree format they are given has a
764
709
        format string, and vice versa.
765
710
 
766
 
        If workingtree_format is None, the transport is returned with no
 
711
        If workingtree_format is None, the transport is returned with no 
767
712
        checking. If it is not None, then the returned transport is
768
713
        guaranteed to point to an existing directory ready for use.
769
714
        """
770
715
        raise NotImplementedError(self.get_workingtree_transport)
771
716
 
772
717
    def get_config(self):
773
 
        """Get configuration for this BzrDir."""
774
 
        return config.BzrDirConfig(self)
775
 
 
776
 
    def _get_config(self):
777
 
        """By default, no configuration is available."""
778
 
        return None
 
718
        if getattr(self, '_get_config', None) is None:
 
719
            return None
 
720
        return self._get_config()
779
721
 
780
722
    def __init__(self, _transport, _format):
781
723
        """Initialize a Bzr control dir object.
782
 
 
 
724
        
783
725
        Only really common logic should reside here, concrete classes should be
784
726
        made with varying behaviours.
785
727
 
793
735
 
794
736
    def is_control_filename(self, filename):
795
737
        """True if filename is the name of a path which is reserved for bzrdir's.
796
 
 
 
738
        
797
739
        :param filename: A filename within the root transport of this bzrdir.
798
740
 
799
741
        This is true IF and ONLY IF the filename is part of the namespace reserved
802
744
        this in the future - for instance to make bzr talk with svn working
803
745
        trees.
804
746
        """
805
 
        # this might be better on the BzrDirFormat class because it refers to
806
 
        # all the possible bzrdir disk formats.
807
 
        # This method is tested via the workingtree is_control_filename tests-
 
747
        # this might be better on the BzrDirFormat class because it refers to 
 
748
        # all the possible bzrdir disk formats. 
 
749
        # This method is tested via the workingtree is_control_filename tests- 
808
750
        # it was extracted from WorkingTree.is_control_filename. If the method's
809
751
        # contract is extended beyond the current trivial implementation, please
810
752
        # add new tests for it to the appropriate place.
812
754
 
813
755
    def needs_format_conversion(self, format=None):
814
756
        """Return true if this bzrdir needs convert_format run on it.
815
 
 
816
 
        For instance, if the repository format is out of date but the
 
757
        
 
758
        For instance, if the repository format is out of date but the 
817
759
        branch and working tree are not, this should return True.
818
760
 
819
761
        :param format: Optional parameter indicating a specific desired
825
767
    def open_unsupported(base):
826
768
        """Open a branch which is not supported."""
827
769
        return BzrDir.open(base, _unsupported=True)
828
 
 
 
770
        
829
771
    @staticmethod
830
772
    def open(base, _unsupported=False, possible_transports=None):
831
773
        """Open an existing bzrdir, rooted at 'base' (url).
832
 
 
 
774
        
833
775
        :param _unsupported: a private parameter to the BzrDir class.
834
776
        """
835
777
        t = get_transport(base, possible_transports=possible_transports)
843
785
        :param transport: Transport containing the bzrdir.
844
786
        :param _unsupported: private.
845
787
        """
846
 
        for hook in BzrDir.hooks['pre_open']:
847
 
            hook(transport)
848
788
        # Keep initial base since 'transport' may be modified while following
849
789
        # the redirections.
850
790
        base = transport.base
870
810
        BzrDir._check_supported(format, _unsupported)
871
811
        return format.open(transport, _found=True)
872
812
 
873
 
    def open_branch(self, unsupported=False, ignore_fallbacks=False):
 
813
    def open_branch(self, unsupported=False):
874
814
        """Open the branch object at this BzrDir if one is present.
875
815
 
876
816
        If unsupported is True, then no longer supported branch formats can
877
817
        still be opened.
878
 
 
 
818
        
879
819
        TODO: static convenience version of this?
880
820
        """
881
821
        raise NotImplementedError(self.open_branch)
883
823
    @staticmethod
884
824
    def open_containing(url, possible_transports=None):
885
825
        """Open an existing branch which contains url.
886
 
 
 
826
        
887
827
        :param url: url to search from.
888
828
        See open_containing_from_transport for more detail.
889
829
        """
890
830
        transport = get_transport(url, possible_transports)
891
831
        return BzrDir.open_containing_from_transport(transport)
892
 
 
 
832
    
893
833
    @staticmethod
894
834
    def open_containing_from_transport(a_transport):
895
835
        """Open an existing branch which contains a_transport.base.
898
838
 
899
839
        Basically we keep looking up until we find the control directory or
900
840
        run into the root.  If there isn't one, raises NotBranchError.
901
 
        If there is one and it is either an unrecognised format or an unsupported
 
841
        If there is one and it is either an unrecognised format or an unsupported 
902
842
        format, UnknownFormatError or UnsupportedFormatError are raised.
903
843
        If there is one, it is returned, along with the unused portion of url.
904
844
 
905
 
        :return: The BzrDir that contains the path, and a Unicode path
 
845
        :return: The BzrDir that contains the path, and a Unicode path 
906
846
                for the rest of the URL.
907
847
        """
908
848
        # this gets the normalised url back. I.e. '.' -> the full path.
1016
956
 
1017
957
    def has_branch(self):
1018
958
        """Tell if this bzrdir contains a branch.
1019
 
 
 
959
        
1020
960
        Note: if you're going to open the branch, you should just go ahead
1021
 
        and try, and not ask permission first.  (This method just opens the
1022
 
        branch and discards it, and that's somewhat expensive.)
 
961
        and try, and not ask permission first.  (This method just opens the 
 
962
        branch and discards it, and that's somewhat expensive.) 
1023
963
        """
1024
964
        try:
1025
965
            self.open_branch()
1032
972
 
1033
973
        This will still raise an exception if the bzrdir has a workingtree that
1034
974
        is remote & inaccessible.
1035
 
 
 
975
        
1036
976
        Note: if you're going to open the working tree, you should just go ahead
1037
 
        and try, and not ask permission first.  (This method just opens the
1038
 
        workingtree and discards it, and that's somewhat expensive.)
 
977
        and try, and not ask permission first.  (This method just opens the 
 
978
        workingtree and discards it, and that's somewhat expensive.) 
1039
979
        """
1040
980
        try:
1041
981
            self.open_workingtree(recommend_upgrade=False)
1045
985
 
1046
986
    def _cloning_metadir(self):
1047
987
        """Produce a metadir suitable for cloning with.
1048
 
 
 
988
        
1049
989
        :returns: (destination_bzrdir_format, source_repository)
1050
990
        """
1051
991
        result_format = self._format.__class__()
1052
992
        try:
1053
993
            try:
1054
 
                branch = self.open_branch(ignore_fallbacks=True)
 
994
                branch = self.open_branch()
1055
995
                source_repository = branch.repository
1056
996
                result_format._branch_format = branch._format
1057
997
            except errors.NotBranchError:
1094
1034
        """
1095
1035
        format, repository = self._cloning_metadir()
1096
1036
        if format._workingtree_format is None:
1097
 
            # No tree in self.
1098
1037
            if repository is None:
1099
 
                # No repository either
1100
1038
                return format
1101
 
            # We have a repository, so set a working tree? (Why? This seems to
1102
 
            # contradict the stated return value in the docstring).
1103
1039
            tree_format = repository._format._matchingbzrdir.workingtree_format
1104
1040
            format.workingtree_format = tree_format.__class__()
1105
1041
        if require_stacking:
1112
1048
    def sprout(self, url, revision_id=None, force_new_repo=False,
1113
1049
               recurse='down', possible_transports=None,
1114
1050
               accelerator_tree=None, hardlink=False, stacked=False,
1115
 
               source_branch=None, create_tree_if_local=True):
 
1051
               source_branch=None):
1116
1052
        """Create a copy of this bzrdir prepared for use as a new line of
1117
1053
        development.
1118
1054
 
1133
1069
            where possible.
1134
1070
        :param stacked: If true, create a stacked branch referring to the
1135
1071
            location of this control directory.
1136
 
        :param create_tree_if_local: If true, a working-tree will be created
1137
 
            when working locally.
1138
1072
        """
1139
1073
        target_transport = get_transport(url, possible_transports)
1140
1074
        target_transport.ensure_base()
1162
1096
                    source_repository = None
1163
1097
        repository_policy = result.determine_repository_policy(
1164
1098
            force_new_repo, stacked_branch_url, require_stacking=stacked)
1165
 
        result_repo, is_new_repo = repository_policy.acquire_repository()
1166
 
        if is_new_repo and revision_id is not None and not stacked:
1167
 
            fetch_spec = graph.PendingAncestryResult(
1168
 
                [revision_id], source_repository)
1169
 
        else:
1170
 
            fetch_spec = None
 
1099
        result_repo = repository_policy.acquire_repository()
1171
1100
        if source_repository is not None:
1172
1101
            # Fetch while stacked to prevent unstacked fetch from
1173
1102
            # Branch.sprout.
1174
 
            if fetch_spec is None:
1175
 
                result_repo.fetch(source_repository, revision_id=revision_id)
1176
 
            else:
1177
 
                result_repo.fetch(source_repository, fetch_spec=fetch_spec)
 
1103
            result_repo.fetch(source_repository, revision_id=revision_id)
1178
1104
 
1179
1105
        if source_branch is None:
1180
1106
            # this is for sprouting a bzrdir without a branch; is that
1182
1108
            # Not especially, but it's part of the contract.
1183
1109
            result_branch = result.create_branch()
1184
1110
        else:
1185
 
            result_branch = source_branch.sprout(result,
1186
 
                revision_id=revision_id, repository_policy=repository_policy)
 
1111
            # Force NULL revision to avoid using repository before stacking
 
1112
            # is configured.
 
1113
            result_branch = source_branch.sprout(
 
1114
                result, revision_id=_mod_revision.NULL_REVISION)
 
1115
            parent_location = result_branch.get_parent()
1187
1116
        mutter("created new branch %r" % (result_branch,))
 
1117
        repository_policy.configure_branch(result_branch)
 
1118
        if source_branch is not None:
 
1119
            source_branch.copy_content_into(result_branch, revision_id)
 
1120
            # Override copy_content_into
 
1121
            result_branch.set_parent(parent_location)
1188
1122
 
1189
1123
        # Create/update the result working tree
1190
 
        if (create_tree_if_local and
1191
 
            isinstance(target_transport, local.LocalTransport) and
1192
 
            (result_repo is None or result_repo.make_working_trees())):
 
1124
        if isinstance(target_transport, local.LocalTransport) and (
 
1125
            result_repo is None or result_repo.make_working_trees()):
1193
1126
            wt = result.create_workingtree(accelerator_tree=accelerator_tree,
1194
1127
                hardlink=hardlink)
1195
1128
            wt.lock_write()
1232
1165
                    basis.unlock()
1233
1166
        return result
1234
1167
 
1235
 
    def push_branch(self, source, revision_id=None, overwrite=False, 
1236
 
        remember=False):
1237
 
        """Push the source branch into this BzrDir."""
1238
 
        br_to = None
1239
 
        # If we can open a branch, use its direct repository, otherwise see
1240
 
        # if there is a repository without a branch.
1241
 
        try:
1242
 
            br_to = self.open_branch()
1243
 
        except errors.NotBranchError:
1244
 
            # Didn't find a branch, can we find a repository?
1245
 
            repository_to = self.find_repository()
1246
 
        else:
1247
 
            # Found a branch, so we must have found a repository
1248
 
            repository_to = br_to.repository
1249
 
 
1250
 
        push_result = PushResult()
1251
 
        push_result.source_branch = source
1252
 
        if br_to is None:
1253
 
            # We have a repository but no branch, copy the revisions, and then
1254
 
            # create a branch.
1255
 
            repository_to.fetch(source.repository, revision_id=revision_id)
1256
 
            br_to = source.clone(self, revision_id=revision_id)
1257
 
            if source.get_push_location() is None or remember:
1258
 
                source.set_push_location(br_to.base)
1259
 
            push_result.stacked_on = None
1260
 
            push_result.branch_push_result = None
1261
 
            push_result.old_revno = None
1262
 
            push_result.old_revid = _mod_revision.NULL_REVISION
1263
 
            push_result.target_branch = br_to
1264
 
            push_result.master_branch = None
1265
 
            push_result.workingtree_updated = False
1266
 
        else:
1267
 
            # We have successfully opened the branch, remember if necessary:
1268
 
            if source.get_push_location() is None or remember:
1269
 
                source.set_push_location(br_to.base)
1270
 
            try:
1271
 
                tree_to = self.open_workingtree()
1272
 
            except errors.NotLocalUrl:
1273
 
                push_result.branch_push_result = source.push(br_to, 
1274
 
                    overwrite, stop_revision=revision_id)
1275
 
                push_result.workingtree_updated = False
1276
 
            except errors.NoWorkingTree:
1277
 
                push_result.branch_push_result = source.push(br_to,
1278
 
                    overwrite, stop_revision=revision_id)
1279
 
                push_result.workingtree_updated = None # Not applicable
1280
 
            else:
1281
 
                tree_to.lock_write()
1282
 
                try:
1283
 
                    push_result.branch_push_result = source.push(
1284
 
                        tree_to.branch, overwrite, stop_revision=revision_id)
1285
 
                    tree_to.update()
1286
 
                finally:
1287
 
                    tree_to.unlock()
1288
 
                push_result.workingtree_updated = True
1289
 
            push_result.old_revno = push_result.branch_push_result.old_revno
1290
 
            push_result.old_revid = push_result.branch_push_result.old_revid
1291
 
            push_result.target_branch = \
1292
 
                push_result.branch_push_result.target_branch
1293
 
        return push_result
1294
 
 
1295
 
 
1296
 
class BzrDirHooks(hooks.Hooks):
1297
 
    """Hooks for BzrDir operations."""
1298
 
 
1299
 
    def __init__(self):
1300
 
        """Create the default hooks."""
1301
 
        hooks.Hooks.__init__(self)
1302
 
        self.create_hook(hooks.HookPoint('pre_open',
1303
 
            "Invoked before attempting to open a BzrDir with the transport "
1304
 
            "that the open will use.", (1, 14), None))
1305
 
 
1306
 
# install the default hooks
1307
 
BzrDir.hooks = BzrDirHooks()
1308
 
 
1309
1168
 
1310
1169
class BzrDirPreSplitOut(BzrDir):
1311
1170
    """A common class for the all-in-one formats."""
1382
1241
        # and that will have set it for us, its only
1383
1242
        # specific uses of create_workingtree in isolation
1384
1243
        # that can do wonky stuff here, and that only
1385
 
        # happens for creating checkouts, which cannot be
 
1244
        # happens for creating checkouts, which cannot be 
1386
1245
        # done on this format anyway. So - acceptable wart.
1387
1246
        try:
1388
1247
            result = self.open_workingtree(recommend_upgrade=False)
1411
1270
 
1412
1271
    def destroy_workingtree_metadata(self):
1413
1272
        """See BzrDir.destroy_workingtree_metadata."""
1414
 
        raise errors.UnsupportedOperation(self.destroy_workingtree_metadata,
 
1273
        raise errors.UnsupportedOperation(self.destroy_workingtree_metadata, 
1415
1274
                                          self)
1416
1275
 
1417
1276
    def get_branch_transport(self, branch_format):
1449
1308
        # if the format is not the same as the system default,
1450
1309
        # an upgrade is needed.
1451
1310
        if format is None:
1452
 
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
1453
 
                % 'needs_format_conversion(format=None)')
1454
1311
            format = BzrDirFormat.get_default_format()
1455
1312
        return not isinstance(self._format, format.__class__)
1456
1313
 
1457
 
    def open_branch(self, unsupported=False, ignore_fallbacks=False):
 
1314
    def open_branch(self, unsupported=False):
1458
1315
        """See BzrDir.open_branch."""
1459
1316
        from bzrlib.branch import BzrBranchFormat4
1460
1317
        format = BzrBranchFormat4()
1463
1320
 
1464
1321
    def sprout(self, url, revision_id=None, force_new_repo=False,
1465
1322
               possible_transports=None, accelerator_tree=None,
1466
 
               hardlink=False, stacked=False, create_tree_if_local=True,
1467
 
               source_branch=None):
 
1323
               hardlink=False, stacked=False):
1468
1324
        """See BzrDir.sprout()."""
1469
 
        if source_branch is not None:
1470
 
            my_branch = self.open_branch()
1471
 
            if source_branch.base != my_branch.base:
1472
 
                raise AssertionError(
1473
 
                    "source branch %r is not within %r with branch %r" %
1474
 
                    (source_branch, self, my_branch))
1475
1325
        if stacked:
1476
1326
            raise errors.UnstackableBranchFormat(
1477
1327
                self._format, self.root_transport.base)
1478
 
        if not create_tree_if_local:
1479
 
            raise errors.MustHaveWorkingTree(
1480
 
                self._format, self.root_transport.base)
1481
1328
        from bzrlib.workingtree import WorkingTreeFormat2
1482
1329
        self._make_tail(url)
1483
1330
        result = self._format._initialize_for_clone(url)
1489
1336
            self.open_branch().sprout(result, revision_id=revision_id)
1490
1337
        except errors.NotBranchError:
1491
1338
            pass
1492
 
 
1493
1339
        # we always want a working tree
1494
1340
        WorkingTreeFormat2().initialize(result,
1495
1341
                                        accelerator_tree=accelerator_tree,
1499
1345
 
1500
1346
class BzrDir4(BzrDirPreSplitOut):
1501
1347
    """A .bzr version 4 control object.
1502
 
 
 
1348
    
1503
1349
    This is a deprecated format and may be removed after sept 2006.
1504
1350
    """
1505
1351
 
1509
1355
 
1510
1356
    def needs_format_conversion(self, format=None):
1511
1357
        """Format 4 dirs are always in need of conversion."""
1512
 
        if format is None:
1513
 
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
1514
 
                % 'needs_format_conversion(format=None)')
1515
1358
        return True
1516
1359
 
1517
1360
    def open_repository(self):
1563
1406
 
1564
1407
class BzrDirMeta1(BzrDir):
1565
1408
    """A .bzr meta version 1 control object.
1566
 
 
1567
 
    This is the first control object where the
 
1409
    
 
1410
    This is the first control object where the 
1568
1411
    individual aspects are really split out: there are separate repository,
1569
1412
    workingtree and branch subdirectories and any subset of the three can be
1570
1413
    present within a BzrDir.
1673
1516
    def needs_format_conversion(self, format=None):
1674
1517
        """See BzrDir.needs_format_conversion()."""
1675
1518
        if format is None:
1676
 
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
1677
 
                % 'needs_format_conversion(format=None)')
1678
 
        if format is None:
1679
1519
            format = BzrDirFormat.get_default_format()
1680
1520
        if not isinstance(self._format, format.__class__):
1681
1521
            # it is not a meta dir format, conversion is needed.
1705
1545
            pass
1706
1546
        return False
1707
1547
 
1708
 
    def open_branch(self, unsupported=False, ignore_fallbacks=False):
 
1548
    def open_branch(self, unsupported=False):
1709
1549
        """See BzrDir.open_branch."""
1710
1550
        format = self.find_branch_format()
1711
1551
        self._check_supported(format, unsupported)
1712
 
        return format.open(self, _found=True, ignore_fallbacks=ignore_fallbacks)
 
1552
        return format.open(self, _found=True)
1713
1553
 
1714
1554
    def open_repository(self, unsupported=False):
1715
1555
        """See BzrDir.open_repository."""
1729
1569
        return format.open(self, _found=True)
1730
1570
 
1731
1571
    def _get_config(self):
1732
 
        return config.TransportConfig(self.transport, 'control.conf')
 
1572
        return config.BzrDirConfig(self.transport)
1733
1573
 
1734
1574
 
1735
1575
class BzrDirFormat(object):
1740
1580
     * a format string,
1741
1581
     * an open routine.
1742
1582
 
1743
 
    Formats are placed in a dict by their format string for reference
 
1583
    Formats are placed in a dict by their format string for reference 
1744
1584
    during bzrdir opening. These should be subclasses of BzrDirFormat
1745
1585
    for consistency.
1746
1586
 
1747
1587
    Once a format is deprecated, just deprecate the initialize and open
1748
 
    methods on the format class. Do not deprecate the object, as the
 
1588
    methods on the format class. Do not deprecate the object, as the 
1749
1589
    object will be created every system load.
1750
1590
    """
1751
1591
 
1757
1597
 
1758
1598
    _control_formats = []
1759
1599
    """The registered control formats - .bzr, ....
1760
 
 
 
1600
    
1761
1601
    This is a list of BzrDirFormat objects.
1762
1602
    """
1763
1603
 
1822
1662
        current default format. In the case of plugins we can/should provide
1823
1663
        some means for them to extend the range of returnable converters.
1824
1664
 
1825
 
        :param format: Optional format to override the default format of the
 
1665
        :param format: Optional format to override the default format of the 
1826
1666
                       library.
1827
1667
        """
1828
1668
        raise NotImplementedError(self.get_converter)
1829
1669
 
1830
1670
    def initialize(self, url, possible_transports=None):
1831
1671
        """Create a bzr control dir at this url and return an opened copy.
1832
 
 
1833
 
        While not deprecated, this method is very specific and its use will
1834
 
        lead to many round trips to setup a working environment. See
1835
 
        initialize_on_transport_ex for a [nearly] all-in-one method.
1836
 
 
 
1672
        
1837
1673
        Subclasses should typically override initialize_on_transport
1838
1674
        instead of this method.
1839
1675
        """
1842
1678
 
1843
1679
    def initialize_on_transport(self, transport):
1844
1680
        """Initialize a new bzrdir in the base directory of a Transport."""
1845
 
        try:
1846
 
            # can we hand off the request to the smart server rather than using
1847
 
            # vfs calls?
1848
 
            client_medium = transport.get_smart_medium()
1849
 
        except errors.NoSmartMedium:
1850
 
            return self._initialize_on_transport_vfs(transport)
1851
 
        else:
1852
 
            # Current RPC's only know how to create bzr metadir1 instances, so
1853
 
            # we still delegate to vfs methods if the requested format is not a
1854
 
            # metadir1
1855
 
            if type(self) != BzrDirMetaFormat1:
1856
 
                return self._initialize_on_transport_vfs(transport)
1857
 
            remote_format = RemoteBzrDirFormat()
1858
 
            self._supply_sub_formats_to(remote_format)
1859
 
            return remote_format.initialize_on_transport(transport)
1860
 
 
1861
 
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
1862
 
        create_prefix=False, force_new_repo=False, stacked_on=None,
1863
 
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
1864
 
        shared_repo=False, vfs_only=False):
1865
 
        """Create this format on transport.
1866
 
 
1867
 
        The directory to initialize will be created.
1868
 
 
1869
 
        :param force_new_repo: Do not use a shared repository for the target,
1870
 
                               even if one is available.
1871
 
        :param create_prefix: Create any missing directories leading up to
1872
 
            to_transport.
1873
 
        :param use_existing_dir: Use an existing directory if one exists.
1874
 
        :param stacked_on: A url to stack any created branch on, None to follow
1875
 
            any target stacking policy.
1876
 
        :param stack_on_pwd: If stack_on is relative, the location it is
1877
 
            relative to.
1878
 
        :param repo_format_name: If non-None, a repository will be
1879
 
            made-or-found. Should none be found, or if force_new_repo is True
1880
 
            the repo_format_name is used to select the format of repository to
1881
 
            create.
1882
 
        :param make_working_trees: Control the setting of make_working_trees
1883
 
            for a new shared repository when one is made. None to use whatever
1884
 
            default the format has.
1885
 
        :param shared_repo: Control whether made repositories are shared or
1886
 
            not.
1887
 
        :param vfs_only: If True do not attempt to use a smart server
1888
 
        :return: repo, bzrdir, require_stacking, repository_policy. repo is
1889
 
            None if none was created or found, bzrdir is always valid.
1890
 
            require_stacking is the result of examining the stacked_on
1891
 
            parameter and any stacking policy found for the target.
1892
 
        """
1893
 
        if not vfs_only:
1894
 
            # Try to hand off to a smart server 
1895
 
            try:
1896
 
                client_medium = transport.get_smart_medium()
1897
 
            except errors.NoSmartMedium:
1898
 
                pass
1899
 
            else:
1900
 
                # TODO: lookup the local format from a server hint.
1901
 
                remote_dir_format = RemoteBzrDirFormat()
1902
 
                remote_dir_format._network_name = self.network_name()
1903
 
                self._supply_sub_formats_to(remote_dir_format)
1904
 
                return remote_dir_format.initialize_on_transport_ex(transport,
1905
 
                    use_existing_dir=use_existing_dir, create_prefix=create_prefix,
1906
 
                    force_new_repo=force_new_repo, stacked_on=stacked_on,
1907
 
                    stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
1908
 
                    make_working_trees=make_working_trees, shared_repo=shared_repo)
1909
 
        # XXX: Refactor the create_prefix/no_create_prefix code into a
1910
 
        #      common helper function
1911
 
        # The destination may not exist - if so make it according to policy.
1912
 
        def make_directory(transport):
1913
 
            transport.mkdir('.')
1914
 
            return transport
1915
 
        def redirected(transport, e, redirection_notice):
1916
 
            note(redirection_notice)
1917
 
            return transport._redirected_to(e.source, e.target)
1918
 
        try:
1919
 
            transport = do_catching_redirections(make_directory, transport,
1920
 
                redirected)
1921
 
        except errors.FileExists:
1922
 
            if not use_existing_dir:
1923
 
                raise
1924
 
        except errors.NoSuchFile:
1925
 
            if not create_prefix:
1926
 
                raise
1927
 
            transport.create_prefix()
1928
 
 
1929
 
        require_stacking = (stacked_on is not None)
1930
 
        # Now the target directory exists, but doesn't have a .bzr
1931
 
        # directory. So we need to create it, along with any work to create
1932
 
        # all of the dependent branches, etc.
1933
 
 
1934
 
        result = self.initialize_on_transport(transport)
1935
 
        if repo_format_name:
1936
 
            try:
1937
 
                # use a custom format
1938
 
                result._format.repository_format = \
1939
 
                    repository.network_format_registry.get(repo_format_name)
1940
 
            except AttributeError:
1941
 
                # The format didn't permit it to be set.
1942
 
                pass
1943
 
            # A repository is desired, either in-place or shared.
1944
 
            repository_policy = result.determine_repository_policy(
1945
 
                force_new_repo, stacked_on, stack_on_pwd,
1946
 
                require_stacking=require_stacking)
1947
 
            result_repo, is_new_repo = repository_policy.acquire_repository(
1948
 
                make_working_trees, shared_repo)
1949
 
            if not require_stacking and repository_policy._require_stacking:
1950
 
                require_stacking = True
1951
 
                result._format.require_stacking()
1952
 
            result_repo.lock_write()
1953
 
        else:
1954
 
            result_repo = None
1955
 
            repository_policy = None
1956
 
        return result_repo, result, require_stacking, repository_policy
1957
 
 
1958
 
    def _initialize_on_transport_vfs(self, transport):
1959
 
        """Initialize a new bzrdir using VFS calls.
1960
 
 
1961
 
        :param transport: The transport to create the .bzr directory in.
1962
 
        :return: A
1963
 
        """
1964
 
        # Since we are creating a .bzr directory, inherit the
 
1681
        # Since we don't have a .bzr directory, inherit the
1965
1682
        # mode from the root directory
1966
1683
        temp_control = lockable_files.LockableFiles(transport,
1967
1684
                            '', lockable_files.TransportLock)
1997
1714
        """Is this format supported?
1998
1715
 
1999
1716
        Supported formats must be initializable and openable.
2000
 
        Unsupported formats may not support initialization or committing or
 
1717
        Unsupported formats may not support initialization or committing or 
2001
1718
        some other features depending on the reason for not being supported.
2002
1719
        """
2003
1720
        return True
2004
1721
 
2005
 
    def network_name(self):
2006
 
        """A simple byte string uniquely identifying this format for RPC calls.
2007
 
 
2008
 
        Bzr control formats use thir disk format string to identify the format
2009
 
        over the wire. Its possible that other control formats have more
2010
 
        complex detection requirements, so we permit them to use any unique and
2011
 
        immutable string they desire.
2012
 
        """
2013
 
        raise NotImplementedError(self.network_name)
2014
 
 
2015
1722
    def same_model(self, target_format):
2016
 
        return (self.repository_format.rich_root_data ==
 
1723
        return (self.repository_format.rich_root_data == 
2017
1724
            target_format.rich_root_data)
2018
1725
 
2019
1726
    @classmethod
2020
1727
    def known_formats(klass):
2021
1728
        """Return all the known formats.
2022
 
 
 
1729
        
2023
1730
        Concrete formats should override _known_formats.
2024
1731
        """
2025
 
        # There is double indirection here to make sure that control
2026
 
        # formats used by more than one dir format will only be probed
 
1732
        # There is double indirection here to make sure that control 
 
1733
        # formats used by more than one dir format will only be probed 
2027
1734
        # once. This can otherwise be quite expensive for remote connections.
2028
1735
        result = set()
2029
1736
        for format in klass._control_formats:
2030
1737
            result.update(format._known_formats())
2031
1738
        return result
2032
 
 
 
1739
    
2033
1740
    @classmethod
2034
1741
    def _known_formats(klass):
2035
1742
        """Return the known format instances for this control format."""
2037
1744
 
2038
1745
    def open(self, transport, _found=False):
2039
1746
        """Return an instance of this format for the dir transport points at.
2040
 
 
 
1747
        
2041
1748
        _found is a private parameter, do not use it.
2042
1749
        """
2043
1750
        if not _found:
2044
1751
            found_format = BzrDirFormat.find_format(transport)
2045
1752
            if not isinstance(found_format, self.__class__):
2046
1753
                raise AssertionError("%s was asked to open %s, but it seems to need "
2047
 
                        "format %s"
 
1754
                        "format %s" 
2048
1755
                        % (self, transport, found_format))
2049
 
            # Allow subclasses - use the found format.
2050
 
            self._supply_sub_formats_to(found_format)
2051
 
            return found_format._open(transport)
2052
1756
        return self._open(transport)
2053
1757
 
2054
1758
    def _open(self, transport):
2062
1766
    @classmethod
2063
1767
    def register_format(klass, format):
2064
1768
        klass._formats[format.get_format_string()] = format
2065
 
        # bzr native formats have a network name of their format string.
2066
 
        network_format_registry.register(format.get_format_string(), format.__class__)
2067
1769
 
2068
1770
    @classmethod
2069
1771
    def register_control_format(klass, format):
2070
1772
        """Register a format that does not use '.bzr' for its control dir.
2071
1773
 
2072
1774
        TODO: This should be pulled up into a 'ControlDirFormat' base class
2073
 
        which BzrDirFormat can inherit from, and renamed to register_format
 
1775
        which BzrDirFormat can inherit from, and renamed to register_format 
2074
1776
        there. It has been done without that for now for simplicity of
2075
1777
        implementation.
2076
1778
        """
2094
1796
 
2095
1797
    def __str__(self):
2096
1798
        # Trim the newline
2097
 
        return self.get_format_description().rstrip()
2098
 
 
2099
 
    def _supply_sub_formats_to(self, other_format):
2100
 
        """Give other_format the same values for sub formats as this has.
2101
 
 
2102
 
        This method is expected to be used when parameterising a
2103
 
        RemoteBzrDirFormat instance with the parameters from a
2104
 
        BzrDirMetaFormat1 instance.
2105
 
 
2106
 
        :param other_format: other_format is a format which should be
2107
 
            compatible with whatever sub formats are supported by self.
2108
 
        :return: None.
2109
 
        """
 
1799
        return self.get_format_string().rstrip()
2110
1800
 
2111
1801
    @classmethod
2112
1802
    def unregister_format(klass, format):
2144
1834
        """See BzrDirFormat.get_converter()."""
2145
1835
        # there is one and only one upgrade path here.
2146
1836
        return ConvertBzrDir4To5()
2147
 
 
 
1837
        
2148
1838
    def initialize_on_transport(self, transport):
2149
1839
        """Format 4 branches cannot be created."""
2150
1840
        raise errors.UninitializableFormat(self)
2153
1843
        """Format 4 is not supported.
2154
1844
 
2155
1845
        It is not supported because the model changed from 4 to 5 and the
2156
 
        conversion logic is expensive - so doing it on the fly was not
 
1846
        conversion logic is expensive - so doing it on the fly was not 
2157
1847
        feasible.
2158
1848
        """
2159
1849
        return False
2160
1850
 
2161
 
    def network_name(self):
2162
 
        return self.get_format_string()
2163
 
 
2164
1851
    def _open(self, transport):
2165
1852
        """See BzrDirFormat._open."""
2166
1853
        return BzrDir4(transport, self)
2172
1859
    repository_format = property(__return_repository_format)
2173
1860
 
2174
1861
 
2175
 
class BzrDirFormatAllInOne(BzrDirFormat):
2176
 
    """Common class for formats before meta-dirs."""
2177
 
 
2178
 
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
2179
 
        create_prefix=False, force_new_repo=False, stacked_on=None,
2180
 
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
2181
 
        shared_repo=False):
2182
 
        """See BzrDirFormat.initialize_on_transport_ex."""
2183
 
        require_stacking = (stacked_on is not None)
2184
 
        # Format 5 cannot stack, but we've been asked to - actually init
2185
 
        # a Meta1Dir
2186
 
        if require_stacking:
2187
 
            format = BzrDirMetaFormat1()
2188
 
            return format.initialize_on_transport_ex(transport,
2189
 
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
2190
 
                force_new_repo=force_new_repo, stacked_on=stacked_on,
2191
 
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
2192
 
                make_working_trees=make_working_trees, shared_repo=shared_repo)
2193
 
        return BzrDirFormat.initialize_on_transport_ex(self, transport,
2194
 
            use_existing_dir=use_existing_dir, create_prefix=create_prefix,
2195
 
            force_new_repo=force_new_repo, stacked_on=stacked_on,
2196
 
            stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
2197
 
            make_working_trees=make_working_trees, shared_repo=shared_repo)
2198
 
 
2199
 
 
2200
 
class BzrDirFormat5(BzrDirFormatAllInOne):
 
1862
class BzrDirFormat5(BzrDirFormat):
2201
1863
    """Bzr control format 5.
2202
1864
 
2203
1865
    This format is a combined format for working tree, branch and repository.
2204
1866
    It has:
2205
 
     - Format 2 working trees [always]
2206
 
     - Format 4 branches [always]
 
1867
     - Format 2 working trees [always] 
 
1868
     - Format 4 branches [always] 
2207
1869
     - Format 5 repositories [always]
2208
1870
       Unhashed stores in the repository.
2209
1871
    """
2229
1891
 
2230
1892
    def _initialize_for_clone(self, url):
2231
1893
        return self.initialize_on_transport(get_transport(url), _cloning=True)
2232
 
 
 
1894
        
2233
1895
    def initialize_on_transport(self, transport, _cloning=False):
2234
1896
        """Format 5 dirs always have working tree, branch and repository.
2235
 
 
 
1897
        
2236
1898
        Except when they are being cloned.
2237
1899
        """
2238
1900
        from bzrlib.branch import BzrBranchFormat4
2244
1906
            result._init_workingtree()
2245
1907
        return result
2246
1908
 
2247
 
    def network_name(self):
2248
 
        return self.get_format_string()
2249
 
 
2250
1909
    def _open(self, transport):
2251
1910
        """See BzrDirFormat._open."""
2252
1911
        return BzrDir5(transport, self)
2258
1917
    repository_format = property(__return_repository_format)
2259
1918
 
2260
1919
 
2261
 
class BzrDirFormat6(BzrDirFormatAllInOne):
 
1920
class BzrDirFormat6(BzrDirFormat):
2262
1921
    """Bzr control format 6.
2263
1922
 
2264
1923
    This format is a combined format for working tree, branch and repository.
2265
1924
    It has:
2266
 
     - Format 2 working trees [always]
2267
 
     - Format 4 branches [always]
 
1925
     - Format 2 working trees [always] 
 
1926
     - Format 4 branches [always] 
2268
1927
     - Format 6 repositories [always]
2269
1928
    """
2270
1929
 
2286
1945
        """See BzrDirFormat.get_converter()."""
2287
1946
        # there is one and only one upgrade path here.
2288
1947
        return ConvertBzrDir6ToMeta()
2289
 
 
 
1948
        
2290
1949
    def _initialize_for_clone(self, url):
2291
1950
        return self.initialize_on_transport(get_transport(url), _cloning=True)
2292
1951
 
2293
1952
    def initialize_on_transport(self, transport, _cloning=False):
2294
1953
        """Format 6 dirs always have working tree, branch and repository.
2295
 
 
 
1954
        
2296
1955
        Except when they are being cloned.
2297
1956
        """
2298
1957
        from bzrlib.branch import BzrBranchFormat4
2304
1963
            result._init_workingtree()
2305
1964
        return result
2306
1965
 
2307
 
    def network_name(self):
2308
 
        return self.get_format_string()
2309
 
 
2310
1966
    def _open(self, transport):
2311
1967
        """See BzrDirFormat._open."""
2312
1968
        return BzrDir6(transport, self)
2334
1990
    def __init__(self):
2335
1991
        self._workingtree_format = None
2336
1992
        self._branch_format = None
2337
 
        self._repository_format = None
2338
1993
 
2339
1994
    def __eq__(self, other):
2340
1995
        if other.__class__ is not self.__class__:
2357
2012
    def set_branch_format(self, format):
2358
2013
        self._branch_format = format
2359
2014
 
2360
 
    def require_stacking(self, stack_on=None, possible_transports=None,
2361
 
            _skip_repo=False):
2362
 
        """We have a request to stack, try to ensure the formats support it.
2363
 
 
2364
 
        :param stack_on: If supplied, it is the URL to a branch that we want to
2365
 
            stack on. Check to see if that format supports stacking before
2366
 
            forcing an upgrade.
2367
 
        """
2368
 
        # Stacking is desired. requested by the target, but does the place it
2369
 
        # points at support stacking? If it doesn't then we should
2370
 
        # not implicitly upgrade. We check this here.
2371
 
        new_repo_format = None
2372
 
        new_branch_format = None
2373
 
 
2374
 
        # a bit of state for get_target_branch so that we don't try to open it
2375
 
        # 2 times, for both repo *and* branch
2376
 
        target = [None, False, None] # target_branch, checked, upgrade anyway
2377
 
        def get_target_branch():
2378
 
            if target[1]:
2379
 
                # We've checked, don't check again
2380
 
                return target
2381
 
            if stack_on is None:
2382
 
                # No target format, that means we want to force upgrading
2383
 
                target[:] = [None, True, True]
2384
 
                return target
2385
 
            try:
2386
 
                target_dir = BzrDir.open(stack_on,
2387
 
                    possible_transports=possible_transports)
2388
 
            except errors.NotBranchError:
2389
 
                # Nothing there, don't change formats
2390
 
                target[:] = [None, True, False]
2391
 
                return target
2392
 
            except errors.JailBreak:
2393
 
                # JailBreak, JFDI and upgrade anyway
2394
 
                target[:] = [None, True, True]
2395
 
                return target
2396
 
            try:
2397
 
                target_branch = target_dir.open_branch()
2398
 
            except errors.NotBranchError:
2399
 
                # No branch, don't upgrade formats
2400
 
                target[:] = [None, True, False]
2401
 
                return target
2402
 
            target[:] = [target_branch, True, False]
2403
 
            return target
2404
 
 
2405
 
        if (not _skip_repo and
2406
 
                 not self.repository_format.supports_external_lookups):
2407
 
            # We need to upgrade the Repository.
2408
 
            target_branch, _, do_upgrade = get_target_branch()
2409
 
            if target_branch is None:
2410
 
                # We don't have a target branch, should we upgrade anyway?
2411
 
                if do_upgrade:
2412
 
                    # stack_on is inaccessible, JFDI.
2413
 
                    # TODO: bad monkey, hard-coded formats...
2414
 
                    if self.repository_format.rich_root_data:
2415
 
                        new_repo_format = pack_repo.RepositoryFormatKnitPack5RichRoot()
2416
 
                    else:
2417
 
                        new_repo_format = pack_repo.RepositoryFormatKnitPack5()
2418
 
            else:
2419
 
                # If the target already supports stacking, then we know the
2420
 
                # project is already able to use stacking, so auto-upgrade
2421
 
                # for them
2422
 
                new_repo_format = target_branch.repository._format
2423
 
                if not new_repo_format.supports_external_lookups:
2424
 
                    # target doesn't, source doesn't, so don't auto upgrade
2425
 
                    # repo
2426
 
                    new_repo_format = None
2427
 
            if new_repo_format is not None:
2428
 
                self.repository_format = new_repo_format
2429
 
                note('Source repository format does not support stacking,'
2430
 
                     ' using format:\n  %s',
2431
 
                     new_repo_format.get_format_description())
2432
 
 
 
2015
    def require_stacking(self):
2433
2016
        if not self.get_branch_format().supports_stacking():
2434
 
            # We just checked the repo, now lets check if we need to
2435
 
            # upgrade the branch format
2436
 
            target_branch, _, do_upgrade = get_target_branch()
2437
 
            if target_branch is None:
2438
 
                if do_upgrade:
2439
 
                    # TODO: bad monkey, hard-coded formats...
2440
 
                    new_branch_format = branch.BzrBranchFormat7()
 
2017
            # We need to make a stacked branch, but the default format for the
 
2018
            # target doesn't support stacking.  So force a branch that *can*
 
2019
            # support stacking.
 
2020
            from bzrlib.branch import BzrBranchFormat7
 
2021
            self._branch_format = BzrBranchFormat7()
 
2022
            mutter("using %r for stacking" % (self._branch_format,))
 
2023
            from bzrlib.repofmt import pack_repo
 
2024
            if self.repository_format.rich_root_data:
 
2025
                bzrdir_format_name = '1.6.1-rich-root'
 
2026
                repo_format = pack_repo.RepositoryFormatKnitPack5RichRoot()
2441
2027
            else:
2442
 
                new_branch_format = target_branch._format
2443
 
                if not new_branch_format.supports_stacking():
2444
 
                    new_branch_format = None
2445
 
            if new_branch_format is not None:
2446
 
                # Does support stacking, use its format.
2447
 
                self.set_branch_format(new_branch_format)
2448
 
                note('Source branch format does not support stacking,'
2449
 
                     ' using format:\n  %s',
2450
 
                     new_branch_format.get_format_description())
 
2028
                bzrdir_format_name = '1.6'
 
2029
                repo_format = pack_repo.RepositoryFormatKnitPack5()
 
2030
            note('Source format does not support stacking, using format:'
 
2031
                 ' \'%s\'\n  %s\n',
 
2032
                 bzrdir_format_name, repo_format.get_format_description())
 
2033
            self.repository_format = repo_format
2451
2034
 
2452
2035
    def get_converter(self, format=None):
2453
2036
        """See BzrDirFormat.get_converter()."""
2466
2049
        """See BzrDirFormat.get_format_description()."""
2467
2050
        return "Meta directory format 1"
2468
2051
 
2469
 
    def network_name(self):
2470
 
        return self.get_format_string()
2471
 
 
2472
2052
    def _open(self, transport):
2473
2053
        """See BzrDirFormat._open."""
2474
 
        # Create a new format instance because otherwise initialisation of new
2475
 
        # metadirs share the global default format object leading to alias
2476
 
        # problems.
2477
 
        format = BzrDirMetaFormat1()
2478
 
        self._supply_sub_formats_to(format)
2479
 
        return BzrDirMeta1(transport, format)
 
2054
        return BzrDirMeta1(transport, self)
2480
2055
 
2481
2056
    def __return_repository_format(self):
2482
2057
        """Circular import protection."""
2483
 
        if self._repository_format:
 
2058
        if getattr(self, '_repository_format', None):
2484
2059
            return self._repository_format
2485
2060
        from bzrlib.repository import RepositoryFormat
2486
2061
        return RepositoryFormat.get_default_format()
2487
2062
 
2488
 
    def _set_repository_format(self, value):
 
2063
    def __set_repository_format(self, value):
2489
2064
        """Allow changing the repository format for metadir formats."""
2490
2065
        self._repository_format = value
2491
2066
 
2492
 
    repository_format = property(__return_repository_format,
2493
 
        _set_repository_format)
2494
 
 
2495
 
    def _supply_sub_formats_to(self, other_format):
2496
 
        """Give other_format the same values for sub formats as this has.
2497
 
 
2498
 
        This method is expected to be used when parameterising a
2499
 
        RemoteBzrDirFormat instance with the parameters from a
2500
 
        BzrDirMetaFormat1 instance.
2501
 
 
2502
 
        :param other_format: other_format is a format which should be
2503
 
            compatible with whatever sub formats are supported by self.
2504
 
        :return: None.
2505
 
        """
2506
 
        if getattr(self, '_repository_format', None) is not None:
2507
 
            other_format.repository_format = self.repository_format
2508
 
        if self._branch_format is not None:
2509
 
            other_format._branch_format = self._branch_format
2510
 
        if self._workingtree_format is not None:
2511
 
            other_format.workingtree_format = self.workingtree_format
 
2067
    repository_format = property(__return_repository_format, __set_repository_format)
2512
2068
 
2513
2069
    def __get_workingtree_format(self):
2514
2070
        if self._workingtree_format is None:
2523
2079
                                  __set_workingtree_format)
2524
2080
 
2525
2081
 
2526
 
network_format_registry = registry.FormatRegistry()
2527
 
"""Registry of formats indexed by their network name.
2528
 
 
2529
 
The network name for a BzrDirFormat is an identifier that can be used when
2530
 
referring to formats with smart server operations. See
2531
 
BzrDirFormat.network_name() for more detail.
2532
 
"""
2533
 
 
2534
 
 
2535
2082
# Register bzr control format
2536
2083
BzrDirFormat.register_control_format(BzrDirFormat)
2537
2084
 
2569
2116
        self.absent_revisions = set()
2570
2117
        self.text_count = 0
2571
2118
        self.revisions = {}
2572
 
 
 
2119
        
2573
2120
    def convert(self, to_convert, pb):
2574
2121
        """See Converter.convert()."""
2575
2122
        self.bzrdir = to_convert
2681
2228
                revision_store.add_lines(key, None, osutils.split_lines(text))
2682
2229
        finally:
2683
2230
            self.pb.clear()
2684
 
 
 
2231
            
2685
2232
    def _load_one_rev(self, rev_id):
2686
2233
        """Load a revision object into memory.
2687
2234
 
2761
2308
        text_changed = False
2762
2309
        parent_candiate_entries = ie.parent_candidates(parent_invs)
2763
2310
        heads = graph.Graph(self).heads(parent_candiate_entries.keys())
2764
 
        # XXX: Note that this is unordered - and this is tolerable because
 
2311
        # XXX: Note that this is unordered - and this is tolerable because 
2765
2312
        # the previous code was also unordered.
2766
2313
        previous_entries = dict((head, parent_candiate_entries[head]) for head
2767
2314
            in heads)
2768
2315
        self.snapshot_ie(previous_entries, ie, w, rev_id)
2769
2316
        del ie.text_id
2770
2317
 
 
2318
    @symbol_versioning.deprecated_method(symbol_versioning.one_one)
 
2319
    def get_parents(self, revision_ids):
 
2320
        for revision_id in revision_ids:
 
2321
            yield self.revisions[revision_id].parent_ids
 
2322
 
2771
2323
    def get_parent_map(self, revision_ids):
2772
 
        """See graph.StackedParentsProvider.get_parent_map"""
 
2324
        """See graph._StackedParentsProvider.get_parent_map"""
2773
2325
        return dict((revision_id, self.revisions[revision_id])
2774
2326
                    for revision_id in revision_ids
2775
2327
                     if revision_id in self.revisions)
2779
2331
        # a call to:. This needs the path figured out. rather than a work_tree
2780
2332
        # a v4 revision_tree can be given, or something that looks enough like
2781
2333
        # one to give the file content to the entry if it needs it.
2782
 
        # and we need something that looks like a weave store for snapshot to
 
2334
        # and we need something that looks like a weave store for snapshot to 
2783
2335
        # save against.
2784
2336
        #ie.snapshot(rev, PATH, previous_revisions, REVISION_TREE, InMemoryWeaveStore(self.text_weaves))
2785
2337
        if len(previous_revisions) == 1:
2901
2453
        self.bzrdir.transport.mkdir('repository', mode=self.dir_mode)
2902
2454
        self.make_lock('repository')
2903
2455
        # we hard code the formats here because we are converting into
2904
 
        # the meta format. The meta format upgrader can take this to a
 
2456
        # the meta format. The meta format upgrader can take this to a 
2905
2457
        # future format within each component.
2906
2458
        self.put_format('repository', RepositoryFormat7())
2907
2459
        for entry in repository_names:
3022
2574
            while old != new:
3023
2575
                if (old == _mod_branch.BzrBranchFormat5 and
3024
2576
                    new in (_mod_branch.BzrBranchFormat6,
3025
 
                        _mod_branch.BzrBranchFormat7,
3026
 
                        _mod_branch.BzrBranchFormat8)):
 
2577
                        _mod_branch.BzrBranchFormat7)):
3027
2578
                    branch_converter = _mod_branch.Converter5to6()
3028
2579
                elif (old == _mod_branch.BzrBranchFormat6 and
3029
 
                    new in (_mod_branch.BzrBranchFormat7,
3030
 
                            _mod_branch.BzrBranchFormat8)):
 
2580
                    new == _mod_branch.BzrBranchFormat7):
3031
2581
                    branch_converter = _mod_branch.Converter6to7()
3032
 
                elif (old == _mod_branch.BzrBranchFormat7 and
3033
 
                      new is _mod_branch.BzrBranchFormat8):
3034
 
                    branch_converter = _mod_branch.Converter7to8()
3035
2582
                else:
3036
2583
                    raise errors.BadConversionTarget("No converter", new)
3037
2584
                branch_converter.convert(branch)
3054
2601
                isinstance(self.target_format.workingtree_format,
3055
2602
                    workingtree_4.WorkingTreeFormat5)):
3056
2603
                workingtree_4.Converter4to5().convert(tree)
3057
 
            if (isinstance(tree, workingtree_4.DirStateWorkingTree) and
3058
 
                not isinstance(tree, workingtree_4.WorkingTree6) and
3059
 
                isinstance(self.target_format.workingtree_format,
3060
 
                    workingtree_4.WorkingTreeFormat6)):
3061
 
                workingtree_4.Converter4or5to6().convert(tree)
3062
2604
        return to_convert
3063
2605
 
3064
2606
 
3065
 
# This is not in remote.py because it's relatively small, and needs to be
3066
 
# registered. Putting it in remote.py creates a circular import problem.
 
2607
# This is not in remote.py because it's small, and needs to be registered.
 
2608
# Putting it in remote.py creates a circular import problem.
3067
2609
# we can make it a lazy object if the control formats is turned into something
3068
2610
# like a registry.
3069
2611
class RemoteBzrDirFormat(BzrDirMetaFormat1):
3070
2612
    """Format representing bzrdirs accessed via a smart server"""
3071
2613
 
3072
 
    def __init__(self):
3073
 
        BzrDirMetaFormat1.__init__(self)
3074
 
        self._network_name = None
3075
 
 
3076
2614
    def get_format_description(self):
3077
2615
        return 'bzr remote bzrdir'
3078
 
 
3079
 
    def get_format_string(self):
3080
 
        raise NotImplementedError(self.get_format_string)
3081
 
 
3082
 
    def network_name(self):
3083
 
        if self._network_name:
3084
 
            return self._network_name
3085
 
        else:
3086
 
            raise AssertionError("No network name set.")
3087
 
 
 
2616
    
3088
2617
    @classmethod
3089
2618
    def probe_transport(klass, transport):
3090
2619
        """Return a RemoteBzrDirFormat object if it looks possible."""
3119
2648
            return local_dir_format.initialize_on_transport(transport)
3120
2649
        client = _SmartClient(client_medium)
3121
2650
        path = client.remote_path_from_transport(transport)
3122
 
        try:
3123
 
            response = client.call('BzrDirFormat.initialize', path)
3124
 
        except errors.ErrorFromSmartServer, err:
3125
 
            remote._translate_error(err, path=path)
 
2651
        response = client.call('BzrDirFormat.initialize', path)
3126
2652
        if response[0] != 'ok':
3127
2653
            raise errors.SmartProtocolError('unexpected response code %s' % (response,))
3128
 
        format = RemoteBzrDirFormat()
3129
 
        self._supply_sub_formats_to(format)
3130
 
        return remote.RemoteBzrDir(transport, format)
3131
 
 
3132
 
    def parse_NoneTrueFalse(self, arg):
3133
 
        if not arg:
3134
 
            return None
3135
 
        if arg == 'False':
3136
 
            return False
3137
 
        if arg == 'True':
3138
 
            return True
3139
 
        raise AssertionError("invalid arg %r" % arg)
3140
 
 
3141
 
    def _serialize_NoneTrueFalse(self, arg):
3142
 
        if arg is False:
3143
 
            return 'False'
3144
 
        if arg:
3145
 
            return 'True'
3146
 
        return ''
3147
 
 
3148
 
    def _serialize_NoneString(self, arg):
3149
 
        return arg or ''
3150
 
 
3151
 
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
3152
 
        create_prefix=False, force_new_repo=False, stacked_on=None,
3153
 
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
3154
 
        shared_repo=False):
3155
 
        try:
3156
 
            # hand off the request to the smart server
3157
 
            client_medium = transport.get_smart_medium()
3158
 
        except errors.NoSmartMedium:
3159
 
            do_vfs = True
3160
 
        else:
3161
 
            # Decline to open it if the server doesn't support our required
3162
 
            # version (3) so that the VFS-based transport will do it.
3163
 
            if client_medium.should_probe():
3164
 
                try:
3165
 
                    server_version = client_medium.protocol_version()
3166
 
                    if server_version != '2':
3167
 
                        do_vfs = True
3168
 
                    else:
3169
 
                        do_vfs = False
3170
 
                except errors.SmartProtocolError:
3171
 
                    # Apparently there's no usable smart server there, even though
3172
 
                    # the medium supports the smart protocol.
3173
 
                    do_vfs = True
3174
 
            else:
3175
 
                do_vfs = False
3176
 
        if not do_vfs:
3177
 
            client = _SmartClient(client_medium)
3178
 
            path = client.remote_path_from_transport(transport)
3179
 
            if client_medium._is_remote_before((1, 16)):
3180
 
                do_vfs = True
3181
 
        if do_vfs:
3182
 
            # TODO: lookup the local format from a server hint.
3183
 
            local_dir_format = BzrDirMetaFormat1()
3184
 
            self._supply_sub_formats_to(local_dir_format)
3185
 
            return local_dir_format.initialize_on_transport_ex(transport,
3186
 
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
3187
 
                force_new_repo=force_new_repo, stacked_on=stacked_on,
3188
 
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
3189
 
                make_working_trees=make_working_trees, shared_repo=shared_repo,
3190
 
                vfs_only=True)
3191
 
        return self._initialize_on_transport_ex_rpc(client, path, transport,
3192
 
            use_existing_dir, create_prefix, force_new_repo, stacked_on,
3193
 
            stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
3194
 
 
3195
 
    def _initialize_on_transport_ex_rpc(self, client, path, transport,
3196
 
        use_existing_dir, create_prefix, force_new_repo, stacked_on,
3197
 
        stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
3198
 
        args = []
3199
 
        args.append(self._serialize_NoneTrueFalse(use_existing_dir))
3200
 
        args.append(self._serialize_NoneTrueFalse(create_prefix))
3201
 
        args.append(self._serialize_NoneTrueFalse(force_new_repo))
3202
 
        args.append(self._serialize_NoneString(stacked_on))
3203
 
        # stack_on_pwd is often/usually our transport
3204
 
        if stack_on_pwd:
3205
 
            try:
3206
 
                stack_on_pwd = transport.relpath(stack_on_pwd)
3207
 
                if not stack_on_pwd:
3208
 
                    stack_on_pwd = '.'
3209
 
            except errors.PathNotChild:
3210
 
                pass
3211
 
        args.append(self._serialize_NoneString(stack_on_pwd))
3212
 
        args.append(self._serialize_NoneString(repo_format_name))
3213
 
        args.append(self._serialize_NoneTrueFalse(make_working_trees))
3214
 
        args.append(self._serialize_NoneTrueFalse(shared_repo))
3215
 
        if self._network_name is None:
3216
 
            self._network_name = \
3217
 
            BzrDirFormat.get_default_format().network_name()
3218
 
        try:
3219
 
            response = client.call('BzrDirFormat.initialize_ex_1.16',
3220
 
                self.network_name(), path, *args)
3221
 
        except errors.UnknownSmartMethod:
3222
 
            client._medium._remember_remote_is_before((1,16))
3223
 
            local_dir_format = BzrDirMetaFormat1()
3224
 
            self._supply_sub_formats_to(local_dir_format)
3225
 
            return local_dir_format.initialize_on_transport_ex(transport,
3226
 
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
3227
 
                force_new_repo=force_new_repo, stacked_on=stacked_on,
3228
 
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
3229
 
                make_working_trees=make_working_trees, shared_repo=shared_repo,
3230
 
                vfs_only=True)
3231
 
        except errors.ErrorFromSmartServer, err:
3232
 
            remote._translate_error(err, path=path)
3233
 
        repo_path = response[0]
3234
 
        bzrdir_name = response[6]
3235
 
        require_stacking = response[7]
3236
 
        require_stacking = self.parse_NoneTrueFalse(require_stacking)
3237
 
        format = RemoteBzrDirFormat()
3238
 
        format._network_name = bzrdir_name
3239
 
        self._supply_sub_formats_to(format)
3240
 
        bzrdir = remote.RemoteBzrDir(transport, format, _client=client)
3241
 
        if repo_path:
3242
 
            repo_format = remote.response_tuple_to_repo_format(response[1:])
3243
 
            if repo_path == '.':
3244
 
                repo_path = ''
3245
 
            if repo_path:
3246
 
                repo_bzrdir_format = RemoteBzrDirFormat()
3247
 
                repo_bzrdir_format._network_name = response[5]
3248
 
                repo_bzr = remote.RemoteBzrDir(transport.clone(repo_path),
3249
 
                    repo_bzrdir_format)
3250
 
            else:
3251
 
                repo_bzr = bzrdir
3252
 
            final_stack = response[8] or None
3253
 
            final_stack_pwd = response[9] or None
3254
 
            if final_stack_pwd:
3255
 
                final_stack_pwd = urlutils.join(
3256
 
                    transport.base, final_stack_pwd)
3257
 
            remote_repo = remote.RemoteRepository(repo_bzr, repo_format)
3258
 
            if len(response) > 10:
3259
 
                # Updated server verb that locks remotely.
3260
 
                repo_lock_token = response[10] or None
3261
 
                remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
3262
 
                if repo_lock_token:
3263
 
                    remote_repo.dont_leave_lock_in_place()
3264
 
            else:
3265
 
                remote_repo.lock_write()
3266
 
            policy = UseExistingRepository(remote_repo, final_stack,
3267
 
                final_stack_pwd, require_stacking)
3268
 
            policy.acquire_repository()
3269
 
        else:
3270
 
            remote_repo = None
3271
 
            policy = None
3272
 
        if require_stacking:
3273
 
            # The repo has already been created, but we need to make sure that
3274
 
            # we'll make a stackable branch.
3275
 
            bzrdir._format.require_stacking(_skip_repo=True)
3276
 
        return remote_repo, bzrdir, require_stacking, policy
 
2654
        return remote.RemoteBzrDir(transport)
3277
2655
 
3278
2656
    def _open(self, transport):
3279
 
        return remote.RemoteBzrDir(transport, self)
 
2657
        return remote.RemoteBzrDir(transport)
3280
2658
 
3281
2659
    def __eq__(self, other):
3282
2660
        if not isinstance(other, RemoteBzrDirFormat):
3283
2661
            return False
3284
2662
        return self.get_format_description() == other.get_format_description()
3285
2663
 
3286
 
    def __return_repository_format(self):
3287
 
        # Always return a RemoteRepositoryFormat object, but if a specific bzr
3288
 
        # repository format has been asked for, tell the RemoteRepositoryFormat
3289
 
        # that it should use that for init() etc.
3290
 
        result = remote.RemoteRepositoryFormat()
3291
 
        custom_format = getattr(self, '_repository_format', None)
3292
 
        if custom_format:
3293
 
            if isinstance(custom_format, remote.RemoteRepositoryFormat):
3294
 
                return custom_format
3295
 
            else:
3296
 
                # We will use the custom format to create repositories over the
3297
 
                # wire; expose its details like rich_root_data for code to
3298
 
                # query
3299
 
                result._custom_format = custom_format
3300
 
        return result
3301
 
 
3302
 
    def get_branch_format(self):
3303
 
        result = BzrDirMetaFormat1.get_branch_format(self)
3304
 
        if not isinstance(result, remote.RemoteBranchFormat):
3305
 
            new_result = remote.RemoteBranchFormat()
3306
 
            new_result._custom_format = result
3307
 
            # cache the result
3308
 
            self.set_branch_format(new_result)
3309
 
            result = new_result
3310
 
        return result
3311
 
 
3312
 
    repository_format = property(__return_repository_format,
3313
 
        BzrDirMetaFormat1._set_repository_format) #.im_func)
 
2664
    @property
 
2665
    def repository_format(self):
 
2666
        # Using a property to avoid early loading of remote
 
2667
        return remote.RemoteRepositoryFormat()
3314
2668
 
3315
2669
 
3316
2670
BzrDirFormat.register_control_server_format(RemoteBzrDirFormat)
3327
2681
 
3328
2682
class BzrDirFormatRegistry(registry.Registry):
3329
2683
    """Registry of user-selectable BzrDir subformats.
3330
 
 
 
2684
    
3331
2685
    Differs from BzrDirFormat._control_formats in that it provides sub-formats,
3332
2686
    e.g. BzrDirMeta1 with weave repository.  Also, it's more user-oriented.
3333
2687
    """
3352
2706
        """Register a metadir subformat.
3353
2707
 
3354
2708
        These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
3355
 
        by the Repository/Branch/WorkingTreeformats.
 
2709
        by the Repository format.
3356
2710
 
3357
2711
        :param repository_format: The fully-qualified repository format class
3358
2712
            name as a string.
3392
2746
    def register(self, key, factory, help, native=True, deprecated=False,
3393
2747
                 hidden=False, experimental=False, alias=False):
3394
2748
        """Register a BzrDirFormat factory.
3395
 
 
 
2749
        
3396
2750
        The factory must be a callable that takes one parameter: the key.
3397
2751
        It must produce an instance of the BzrDirFormat when called.
3398
2752
 
3415
2769
 
3416
2770
    def set_default(self, key):
3417
2771
        """Set the 'default' key to be a clone of the supplied key.
3418
 
 
 
2772
        
3419
2773
        This method must be called once and only once.
3420
2774
        """
3421
2775
        registry.Registry.register(self, 'default', self.get(key),
3424
2778
 
3425
2779
    def set_default_repository(self, key):
3426
2780
        """Set the FormatRegistry default and Repository default.
3427
 
 
 
2781
        
3428
2782
        This is a transitional method while Repository.set_default_format
3429
2783
        is deprecated.
3430
2784
        """
3453
2807
        def wrapped(key, help, info):
3454
2808
            if info.native:
3455
2809
                help = '(native) ' + help
3456
 
            return ':%s:\n%s\n\n' % (key,
3457
 
                textwrap.fill(help, initial_indent='    ',
3458
 
                    subsequent_indent='    ',
3459
 
                    break_long_words=False))
 
2810
            return ':%s:\n%s\n\n' % (key, 
 
2811
                    textwrap.fill(help, initial_indent='    ', 
 
2812
                    subsequent_indent='    '))
3460
2813
        if default_realkey is not None:
3461
2814
            output += wrapped(default_realkey, '(default) %s' % default_help,
3462
2815
                              self.get_info('default'))
3536
2889
                stack_on = self._get_full_stack_on()
3537
2890
        try:
3538
2891
            branch.set_stacked_on_url(stack_on)
3539
 
        except (errors.UnstackableBranchFormat,
3540
 
                errors.UnstackableRepositoryFormat):
 
2892
        except errors.UnstackableBranchFormat:
3541
2893
            if self._require_stacking:
3542
2894
                raise
3543
2895
 
3550
2902
        else:
3551
2903
            return urlutils.join(self._stack_on_pwd, self._stack_on)
3552
2904
 
3553
 
    def _add_fallback(self, repository, possible_transports=None):
 
2905
    def _add_fallback(self, repository):
3554
2906
        """Add a fallback to the supplied repository, if stacking is set."""
3555
2907
        stack_on = self._get_full_stack_on()
3556
2908
        if stack_on is None:
3557
2909
            return
3558
 
        try:
3559
 
            stacked_dir = BzrDir.open(stack_on,
3560
 
                                      possible_transports=possible_transports)
3561
 
        except errors.JailBreak:
3562
 
            # We keep the stacking details, but we are in the server code so
3563
 
            # actually stacking is not needed.
3564
 
            return
 
2910
        stacked_dir = BzrDir.open(stack_on)
3565
2911
        try:
3566
2912
            stacked_repo = stacked_dir.open_branch().repository
3567
2913
        except errors.NotBranchError:
3582
2928
        :param make_working_trees: If creating a repository, set
3583
2929
            make_working_trees to this value (if non-None)
3584
2930
        :param shared: If creating a repository, make it shared if True
3585
 
        :return: A repository, is_new_flag (True if the repository was
3586
 
            created).
 
2931
        :return: A repository
3587
2932
        """
3588
2933
        raise NotImplemented(RepositoryAcquisitionPolicy.acquire_repository)
3589
2934
 
3609
2954
 
3610
2955
        Creates the desired repository in the bzrdir we already have.
3611
2956
        """
3612
 
        stack_on = self._get_full_stack_on()
3613
 
        if stack_on:
3614
 
            format = self._bzrdir._format
3615
 
            format.require_stacking(stack_on=stack_on,
3616
 
                                    possible_transports=[self._bzrdir.root_transport])
3617
 
            if not self._require_stacking:
3618
 
                # We have picked up automatic stacking somewhere.
3619
 
                note('Using default stacking branch %s at %s', self._stack_on,
3620
 
                    self._stack_on_pwd)
3621
2957
        repository = self._bzrdir.create_repository(shared=shared)
3622
 
        self._add_fallback(repository,
3623
 
                           possible_transports=[self._bzrdir.transport])
 
2958
        self._add_fallback(repository)
3624
2959
        if make_working_trees is not None:
3625
2960
            repository.set_make_working_trees(make_working_trees)
3626
 
        return repository, True
 
2961
        return repository
3627
2962
 
3628
2963
 
3629
2964
class UseExistingRepository(RepositoryAcquisitionPolicy):
3645
2980
    def acquire_repository(self, make_working_trees=None, shared=False):
3646
2981
        """Implementation of RepositoryAcquisitionPolicy.acquire_repository
3647
2982
 
3648
 
        Returns an existing repository to use.
 
2983
        Returns an existing repository to use
3649
2984
        """
3650
 
        self._add_fallback(self._repository,
3651
 
                       possible_transports=[self._repository.bzrdir.transport])
3652
 
        return self._repository, False
 
2985
        self._add_fallback(self._repository)
 
2986
        return self._repository
3653
2987
 
3654
2988
 
3655
2989
# Please register new formats after old formats so that formats
3656
2990
# appear in chronological order and format descriptions can build
3657
2991
# on previous ones.
3658
2992
format_registry = BzrDirFormatRegistry()
3659
 
# The pre-0.8 formats have their repository format network name registered in
3660
 
# repository.py. MetaDir formats have their repository format network name
3661
 
# inferred from their disk format string.
3662
2993
format_registry.register('weave', BzrDirFormat6,
3663
2994
    'Pre-0.8 format.  Slower than knit and does not'
3664
2995
    ' support checkouts or shared repositories.',
3736
3067
format_registry.register_metadir('rich-root-pack',
3737
3068
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack4',
3738
3069
    help='New in 1.0: A variant of pack-0.92 that supports rich-root data '
3739
 
         '(needed for bzr-svn and bzr-git).',
 
3070
         '(needed for bzr-svn).',
3740
3071
    branch_format='bzrlib.branch.BzrBranchFormat6',
3741
3072
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3742
3073
    )
3751
3082
format_registry.register_metadir('1.6.1-rich-root',
3752
3083
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5RichRoot',
3753
3084
    help='A variant of 1.6 that supports rich-root data '
3754
 
         '(needed for bzr-svn and bzr-git).',
 
3085
         '(needed for bzr-svn).',
3755
3086
    branch_format='bzrlib.branch.BzrBranchFormat7',
3756
3087
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3757
3088
    )
3766
3097
format_registry.register_metadir('1.9-rich-root',
3767
3098
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3768
3099
    help='A variant of 1.9 that supports rich-root data '
3769
 
         '(needed for bzr-svn and bzr-git).',
 
3100
         '(needed for bzr-svn).',
3770
3101
    branch_format='bzrlib.branch.BzrBranchFormat7',
3771
3102
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3772
3103
    )
3773
 
format_registry.register_metadir('1.14',
 
3104
format_registry.register_metadir('1.12-preview',
3774
3105
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3775
 
    help='A working-tree format that supports content filtering.',
 
3106
    help='A working-tree format that supports views and content filtering.',
3776
3107
    branch_format='bzrlib.branch.BzrBranchFormat7',
3777
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat5',
 
3108
    tree_format='bzrlib.workingtree_4.WorkingTreeFormat5',
 
3109
    experimental=True,
3778
3110
    )
3779
 
format_registry.register_metadir('1.14-rich-root',
 
3111
format_registry.register_metadir('1.12-preview-rich-root',
3780
3112
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3781
 
    help='A variant of 1.14 that supports rich-root data '
3782
 
         '(needed for bzr-svn and bzr-git).',
 
3113
    help='A variant of 1.12-preview that supports rich-root data '
 
3114
         '(needed for bzr-svn).',
3783
3115
    branch_format='bzrlib.branch.BzrBranchFormat7',
3784
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat5',
 
3116
    tree_format='bzrlib.workingtree_4.WorkingTreeFormat5',
 
3117
    experimental=True,
3785
3118
    )
3786
 
# The following un-numbered 'development' formats should always just be aliases.
3787
 
format_registry.register_metadir('development-rich-root',
3788
 
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK1',
3789
 
    help='Current development format. Supports rich roots. Can convert data '
3790
 
        'to and from rich-root-pack (and anything compatible with '
3791
 
        'rich-root-pack) format repositories. Repositories and branches in '
3792
 
        'this format can only be read by bzr.dev. Please read '
 
3119
# The following two formats should always just be aliases.
 
3120
format_registry.register_metadir('development',
 
3121
    'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2',
 
3122
    help='Current development format. Can convert data to and from pack-0.92 '
 
3123
        '(and anything compatible with pack-0.92) format repositories. '
 
3124
        'Repositories and branches in this format can only be read by bzr.dev. '
 
3125
        'Please read '
3793
3126
        'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3794
3127
        'before use.',
3795
3128
    branch_format='bzrlib.branch.BzrBranchFormat7',
3796
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
 
3129
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3797
3130
    experimental=True,
3798
3131
    alias=True,
3799
3132
    )
3806
3139
        'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3807
3140
        'before use.',
3808
3141
    branch_format='bzrlib.branch.BzrBranchFormat7',
3809
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
 
3142
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3810
3143
    experimental=True,
3811
 
    alias=False, # Restore to being an alias when an actual development subtree format is added
3812
 
                 # This current non-alias status is simply because we did not introduce a
3813
 
                 # chk based subtree format.
 
3144
    alias=True,
3814
3145
    )
3815
 
 
3816
3146
# And the development formats above will have aliased one of the following:
3817
 
format_registry.register_metadir('development6-rich-root',
3818
 
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK1',
3819
 
    help='pack-1.9 with 255-way hashed CHK inv, group compress, rich roots '
3820
 
        'Please read '
3821
 
        'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3822
 
        'before use.',
3823
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3824
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3825
 
    hidden=True,
3826
 
    experimental=True,
3827
 
    )
3828
 
 
3829
 
format_registry.register_metadir('development7-rich-root',
3830
 
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK2',
3831
 
    help='pack-1.9 with 255-way hashed CHK inv, bencode revision, group compress, '
3832
 
        'rich roots. Please read '
3833
 
        'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
3834
 
        'before use.',
3835
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3836
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3837
 
    hidden=True,
3838
 
    experimental=True,
3839
 
    )
3840
 
 
3841
 
format_registry.register_metadir('2a',
3842
 
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',
3843
 
    help='First format for bzr 2.0 series.\n'
3844
 
        'Uses group-compress storage.\n'
3845
 
        'Provides rich roots which are a one-way transition.\n',
3846
 
        # 'storage in packs, 255-way hashed CHK inventory, bencode revision, group compress, '
3847
 
        # 'rich roots. Supported by bzr 1.16 and later.',
3848
 
    branch_format='bzrlib.branch.BzrBranchFormat7',
3849
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3850
 
    experimental=True,
3851
 
    )
3852
 
 
3853
 
# The following format should be an alias for the rich root equivalent 
3854
 
# of the default format
3855
 
format_registry.register_metadir('default-rich-root',
3856
 
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack4',
3857
 
    help='Default format, rich root variant. (needed for bzr-svn and bzr-git).',
3858
 
    branch_format='bzrlib.branch.BzrBranchFormat6',
3859
 
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3860
 
    alias=True,
 
3147
format_registry.register_metadir('development2',
 
3148
    'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2',
 
3149
    help='1.6.1 with B+Tree based index. '
 
3150
        'Please read '
 
3151
        'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
 
3152
        'before use.',
 
3153
    branch_format='bzrlib.branch.BzrBranchFormat7',
 
3154
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
 
3155
    hidden=True,
 
3156
    experimental=True,
 
3157
    )
 
3158
format_registry.register_metadir('development2-subtree',
 
3159
    'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
 
3160
    help='1.6.1-subtree with B+Tree based index. '
 
3161
        'Please read '
 
3162
        'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
 
3163
        'before use.',
 
3164
    branch_format='bzrlib.branch.BzrBranchFormat7',
 
3165
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
 
3166
    hidden=True,
 
3167
    experimental=True,
3861
3168
    )
3862
3169
# The current format that is made on 'bzr init'.
3863
3170
format_registry.set_default('pack-0.92')