← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bzrdir.py

  • Committer: John Arbash Meinel
  • Date: 2009-02-23 15:29:35 UTC
  • mfrom: (3943.7.7 bzr.code_style_cleanup)
  • mto: This revision was merged to the branch mainline in revision 4033.
  • Revision ID: john@arbash-meinel.com-20090223152935-oel9m92mwcc6nb4h
Merge the removal of all trailing whitespace, and resolve conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bzrdir.py
82
82
 
83
83
class BzrDir(object):
84
84
    """A .bzr control diretory.
85
 
    
 
85
 
86
86
    BzrDir instances let you create or open any of the things that can be
87
87
    found within .bzr - checkouts, branches and repositories.
88
 
    
 
88
 
89
89
    :ivar transport:
90
90
        the transport which this bzr dir is rooted at (i.e. file:///.../.bzr/)
91
91
    :ivar root_transport:
130
130
        basedir=None):
131
131
        """Give an error or warning on old formats.
132
132
 
133
 
        :param format: may be any kind of format - workingtree, branch, 
 
133
        :param format: may be any kind of format - workingtree, branch,
134
134
        or repository.
135
135
 
136
 
        :param allow_unsupported: If true, allow opening 
137
 
        formats that are strongly deprecated, and which may 
 
136
        :param allow_unsupported: If true, allow opening
 
137
        formats that are strongly deprecated, and which may
138
138
        have limited functionality.
139
139
 
140
140
        :param recommend_upgrade: If true (default), warn
248
248
    @classmethod
249
249
    def create(cls, base, format=None, possible_transports=None):
250
250
        """Create a new BzrDir at the url 'base'.
251
 
        
 
251
 
252
252
        :param format: If supplied, the format of branch to create.  If not
253
253
            supplied, the default is used.
254
 
        :param possible_transports: If supplied, a list of transports that 
 
254
        :param possible_transports: If supplied, a list of transports that
255
255
            can be reused to share a remote connection.
256
256
        """
257
257
        if cls is not BzrDir:
357
357
        """Create a new BzrDir, Branch and Repository at the url 'base'.
358
358
 
359
359
        This will use the current default BzrDirFormat unless one is
360
 
        specified, and use whatever 
 
360
        specified, and use whatever
361
361
        repository format that that uses via bzrdir.create_branch and
362
362
        create_repository. If a shared repository is available that is used
363
363
        preferentially.
451
451
        not.
452
452
 
453
453
        This will use the current default BzrDirFormat unless one is
454
 
        specified, and use whatever 
 
454
        specified, and use whatever
455
455
        repository format that that uses via bzrdir.create_branch and
456
456
        create_repository. If a shared repository is available that is used
457
457
        preferentially. Whatever repository is used, its tree creation policy
459
459
 
460
460
        The created Branch object is returned.
461
461
        If a working tree cannot be made due to base not being a file:// url,
462
 
        no error is raised unless force_new_tree is True, in which case no 
 
462
        no error is raised unless force_new_tree is True, in which case no
463
463
        data is created on disk and NotLocalUrl is raised.
464
464
 
465
465
        :param base: The URL to create the branch at.
466
466
        :param force_new_repo: If True a new repository is always created.
467
 
        :param force_new_tree: If True or False force creation of a tree or 
 
467
        :param force_new_tree: If True or False force creation of a tree or
468
468
                               prevent such creation respectively.
469
469
        :param format: Override for the bzrdir format to create.
470
470
        :param possible_transports: An optional reusable transports list.
492
492
        'base' must be a local path or a file:// url.
493
493
 
494
494
        This will use the current default BzrDirFormat unless one is
495
 
        specified, and use whatever 
 
495
        specified, and use whatever
496
496
        repository format that that uses for bzrdirformat.create_workingtree,
497
497
        create_branch and create_repository.
498
498
 
510
510
    def create_workingtree(self, revision_id=None, from_branch=None,
511
511
        accelerator_tree=None, hardlink=False):
512
512
        """Create a working tree at this BzrDir.
513
 
        
 
513
 
514
514
        :param revision_id: create it as of this revision id.
515
515
        :param from_branch: override bzrdir branch (for lightweight checkouts)
516
516
        :param accelerator_tree: A tree which can be used for retrieving file
522
522
 
523
523
    def backup_bzrdir(self):
524
524
        """Backup this bzr control directory.
525
 
        
 
525
 
526
526
        :return: Tuple with old path name and new path name
527
527
        """
528
528
        pb = ui.ui_factory.nested_progress_bar()
652
652
        IncompatibleFormat if the branch format they are given has
653
653
        a format string, and vice versa.
654
654
 
655
 
        If branch_format is None, the transport is returned with no 
 
655
        If branch_format is None, the transport is returned with no
656
656
        checking. If it is not None, then the returned transport is
657
657
        guaranteed to point to an existing directory ready for use.
658
658
        """
701
701
        if not self._mode_check_done:
702
702
            self._find_creation_modes()
703
703
        return self._dir_mode
704
 
        
 
704
 
705
705
    def get_repository_transport(self, repository_format):
706
706
        """Get the transport for use by repository format in this BzrDir.
707
707
 
709
709
        IncompatibleFormat if the repository format they are given has
710
710
        a format string, and vice versa.
711
711
 
712
 
        If repository_format is None, the transport is returned with no 
 
712
        If repository_format is None, the transport is returned with no
713
713
        checking. If it is not None, then the returned transport is
714
714
        guaranteed to point to an existing directory ready for use.
715
715
        """
716
716
        raise NotImplementedError(self.get_repository_transport)
717
 
        
 
717
 
718
718
    def get_workingtree_transport(self, tree_format):
719
719
        """Get the transport for use by workingtree format in this BzrDir.
720
720
 
722
722
        IncompatibleFormat if the workingtree format they are given has a
723
723
        format string, and vice versa.
724
724
 
725
 
        If workingtree_format is None, the transport is returned with no 
 
725
        If workingtree_format is None, the transport is returned with no
726
726
        checking. If it is not None, then the returned transport is
727
727
        guaranteed to point to an existing directory ready for use.
728
728
        """
735
735
 
736
736
    def __init__(self, _transport, _format):
737
737
        """Initialize a Bzr control dir object.
738
 
        
 
738
 
739
739
        Only really common logic should reside here, concrete classes should be
740
740
        made with varying behaviours.
741
741
 
749
749
 
750
750
    def is_control_filename(self, filename):
751
751
        """True if filename is the name of a path which is reserved for bzrdir's.
752
 
        
 
752
 
753
753
        :param filename: A filename within the root transport of this bzrdir.
754
754
 
755
755
        This is true IF and ONLY IF the filename is part of the namespace reserved
758
758
        this in the future - for instance to make bzr talk with svn working
759
759
        trees.
760
760
        """
761
 
        # this might be better on the BzrDirFormat class because it refers to 
762
 
        # all the possible bzrdir disk formats. 
763
 
        # This method is tested via the workingtree is_control_filename tests- 
 
761
        # this might be better on the BzrDirFormat class because it refers to
 
762
        # all the possible bzrdir disk formats.
 
763
        # This method is tested via the workingtree is_control_filename tests-
764
764
        # it was extracted from WorkingTree.is_control_filename. If the method's
765
765
        # contract is extended beyond the current trivial implementation, please
766
766
        # add new tests for it to the appropriate place.
768
768
 
769
769
    def needs_format_conversion(self, format=None):
770
770
        """Return true if this bzrdir needs convert_format run on it.
771
 
        
772
 
        For instance, if the repository format is out of date but the 
 
771
 
 
772
        For instance, if the repository format is out of date but the
773
773
        branch and working tree are not, this should return True.
774
774
 
775
775
        :param format: Optional parameter indicating a specific desired
781
781
    def open_unsupported(base):
782
782
        """Open a branch which is not supported."""
783
783
        return BzrDir.open(base, _unsupported=True)
784
 
        
 
784
 
785
785
    @staticmethod
786
786
    def open(base, _unsupported=False, possible_transports=None):
787
787
        """Open an existing bzrdir, rooted at 'base' (url).
788
 
        
 
788
 
789
789
        :param _unsupported: a private parameter to the BzrDir class.
790
790
        """
791
791
        t = get_transport(base, possible_transports=possible_transports)
829
829
 
830
830
        If unsupported is True, then no longer supported branch formats can
831
831
        still be opened.
832
 
        
 
832
 
833
833
        TODO: static convenience version of this?
834
834
        """
835
835
        raise NotImplementedError(self.open_branch)
837
837
    @staticmethod
838
838
    def open_containing(url, possible_transports=None):
839
839
        """Open an existing branch which contains url.
840
 
        
 
840
 
841
841
        :param url: url to search from.
842
842
        See open_containing_from_transport for more detail.
843
843
        """
844
844
        transport = get_transport(url, possible_transports)
845
845
        return BzrDir.open_containing_from_transport(transport)
846
 
    
 
846
 
847
847
    @staticmethod
848
848
    def open_containing_from_transport(a_transport):
849
849
        """Open an existing branch which contains a_transport.base.
852
852
 
853
853
        Basically we keep looking up until we find the control directory or
854
854
        run into the root.  If there isn't one, raises NotBranchError.
855
 
        If there is one and it is either an unrecognised format or an unsupported 
 
855
        If there is one and it is either an unrecognised format or an unsupported
856
856
        format, UnknownFormatError or UnsupportedFormatError are raised.
857
857
        If there is one, it is returned, along with the unused portion of url.
858
858
 
859
 
        :return: The BzrDir that contains the path, and a Unicode path 
 
859
        :return: The BzrDir that contains the path, and a Unicode path
860
860
                for the rest of the URL.
861
861
        """
862
862
        # this gets the normalised url back. I.e. '.' -> the full path.
970
970
 
971
971
    def has_branch(self):
972
972
        """Tell if this bzrdir contains a branch.
973
 
        
 
973
 
974
974
        Note: if you're going to open the branch, you should just go ahead
975
 
        and try, and not ask permission first.  (This method just opens the 
976
 
        branch and discards it, and that's somewhat expensive.) 
 
975
        and try, and not ask permission first.  (This method just opens the
 
976
        branch and discards it, and that's somewhat expensive.)
977
977
        """
978
978
        try:
979
979
            self.open_branch()
986
986
 
987
987
        This will still raise an exception if the bzrdir has a workingtree that
988
988
        is remote & inaccessible.
989
 
        
 
989
 
990
990
        Note: if you're going to open the working tree, you should just go ahead
991
 
        and try, and not ask permission first.  (This method just opens the 
992
 
        workingtree and discards it, and that's somewhat expensive.) 
 
991
        and try, and not ask permission first.  (This method just opens the
 
992
        workingtree and discards it, and that's somewhat expensive.)
993
993
        """
994
994
        try:
995
995
            self.open_workingtree(recommend_upgrade=False)
999
999
 
1000
1000
    def _cloning_metadir(self):
1001
1001
        """Produce a metadir suitable for cloning with.
1002
 
        
 
1002
 
1003
1003
        :returns: (destination_bzrdir_format, source_repository)
1004
1004
        """
1005
1005
        result_format = self._format.__class__()
1258
1258
        # and that will have set it for us, its only
1259
1259
        # specific uses of create_workingtree in isolation
1260
1260
        # that can do wonky stuff here, and that only
1261
 
        # happens for creating checkouts, which cannot be 
 
1261
        # happens for creating checkouts, which cannot be
1262
1262
        # done on this format anyway. So - acceptable wart.
1263
1263
        try:
1264
1264
            result = self.open_workingtree(recommend_upgrade=False)
1287
1287
 
1288
1288
    def destroy_workingtree_metadata(self):
1289
1289
        """See BzrDir.destroy_workingtree_metadata."""
1290
 
        raise errors.UnsupportedOperation(self.destroy_workingtree_metadata, 
 
1290
        raise errors.UnsupportedOperation(self.destroy_workingtree_metadata,
1291
1291
                                          self)
1292
1292
 
1293
1293
    def get_branch_transport(self, branch_format):
1368
1368
 
1369
1369
class BzrDir4(BzrDirPreSplitOut):
1370
1370
    """A .bzr version 4 control object.
1371
 
    
 
1371
 
1372
1372
    This is a deprecated format and may be removed after sept 2006.
1373
1373
    """
1374
1374
 
1432
1432
 
1433
1433
class BzrDirMeta1(BzrDir):
1434
1434
    """A .bzr meta version 1 control object.
1435
 
    
1436
 
    This is the first control object where the 
 
1435
 
 
1436
    This is the first control object where the
1437
1437
    individual aspects are really split out: there are separate repository,
1438
1438
    workingtree and branch subdirectories and any subset of the three can be
1439
1439
    present within a BzrDir.
1609
1609
     * a format string,
1610
1610
     * an open routine.
1611
1611
 
1612
 
    Formats are placed in a dict by their format string for reference 
 
1612
    Formats are placed in a dict by their format string for reference
1613
1613
    during bzrdir opening. These should be subclasses of BzrDirFormat
1614
1614
    for consistency.
1615
1615
 
1616
1616
    Once a format is deprecated, just deprecate the initialize and open
1617
 
    methods on the format class. Do not deprecate the object, as the 
 
1617
    methods on the format class. Do not deprecate the object, as the
1618
1618
    object will be created every system load.
1619
1619
    """
1620
1620
 
1626
1626
 
1627
1627
    _control_formats = []
1628
1628
    """The registered control formats - .bzr, ....
1629
 
    
 
1629
 
1630
1630
    This is a list of BzrDirFormat objects.
1631
1631
    """
1632
1632
 
1691
1691
        current default format. In the case of plugins we can/should provide
1692
1692
        some means for them to extend the range of returnable converters.
1693
1693
 
1694
 
        :param format: Optional format to override the default format of the 
 
1694
        :param format: Optional format to override the default format of the
1695
1695
                       library.
1696
1696
        """
1697
1697
        raise NotImplementedError(self.get_converter)
1698
1698
 
1699
1699
    def initialize(self, url, possible_transports=None):
1700
1700
        """Create a bzr control dir at this url and return an opened copy.
1701
 
        
 
1701
 
1702
1702
        Subclasses should typically override initialize_on_transport
1703
1703
        instead of this method.
1704
1704
        """
1765
1765
        """Is this format supported?
1766
1766
 
1767
1767
        Supported formats must be initializable and openable.
1768
 
        Unsupported formats may not support initialization or committing or 
 
1768
        Unsupported formats may not support initialization or committing or
1769
1769
        some other features depending on the reason for not being supported.
1770
1770
        """
1771
1771
        return True
1772
1772
 
1773
1773
    def same_model(self, target_format):
1774
 
        return (self.repository_format.rich_root_data == 
 
1774
        return (self.repository_format.rich_root_data ==
1775
1775
            target_format.rich_root_data)
1776
1776
 
1777
1777
    @classmethod
1778
1778
    def known_formats(klass):
1779
1779
        """Return all the known formats.
1780
 
        
 
1780
 
1781
1781
        Concrete formats should override _known_formats.
1782
1782
        """
1783
 
        # There is double indirection here to make sure that control 
1784
 
        # formats used by more than one dir format will only be probed 
 
1783
        # There is double indirection here to make sure that control
 
1784
        # formats used by more than one dir format will only be probed
1785
1785
        # once. This can otherwise be quite expensive for remote connections.
1786
1786
        result = set()
1787
1787
        for format in klass._control_formats:
1788
1788
            result.update(format._known_formats())
1789
1789
        return result
1790
 
    
 
1790
 
1791
1791
    @classmethod
1792
1792
    def _known_formats(klass):
1793
1793
        """Return the known format instances for this control format."""
1795
1795
 
1796
1796
    def open(self, transport, _found=False):
1797
1797
        """Return an instance of this format for the dir transport points at.
1798
 
        
 
1798
 
1799
1799
        _found is a private parameter, do not use it.
1800
1800
        """
1801
1801
        if not _found:
1802
1802
            found_format = BzrDirFormat.find_format(transport)
1803
1803
            if not isinstance(found_format, self.__class__):
1804
1804
                raise AssertionError("%s was asked to open %s, but it seems to need "
1805
 
                        "format %s" 
 
1805
                        "format %s"
1806
1806
                        % (self, transport, found_format))
1807
1807
            # Allow subclasses - use the found format.
1808
1808
            self._supply_sub_formats_to(found_format)
1826
1826
        """Register a format that does not use '.bzr' for its control dir.
1827
1827
 
1828
1828
        TODO: This should be pulled up into a 'ControlDirFormat' base class
1829
 
        which BzrDirFormat can inherit from, and renamed to register_format 
 
1829
        which BzrDirFormat can inherit from, and renamed to register_format
1830
1830
        there. It has been done without that for now for simplicity of
1831
1831
        implementation.
1832
1832
        """
1900
1900
        """See BzrDirFormat.get_converter()."""
1901
1901
        # there is one and only one upgrade path here.
1902
1902
        return ConvertBzrDir4To5()
1903
 
        
 
1903
 
1904
1904
    def initialize_on_transport(self, transport):
1905
1905
        """Format 4 branches cannot be created."""
1906
1906
        raise errors.UninitializableFormat(self)
1909
1909
        """Format 4 is not supported.
1910
1910
 
1911
1911
        It is not supported because the model changed from 4 to 5 and the
1912
 
        conversion logic is expensive - so doing it on the fly was not 
 
1912
        conversion logic is expensive - so doing it on the fly was not
1913
1913
        feasible.
1914
1914
        """
1915
1915
        return False
1930
1930
 
1931
1931
    This format is a combined format for working tree, branch and repository.
1932
1932
    It has:
1933
 
     - Format 2 working trees [always] 
1934
 
     - Format 4 branches [always] 
 
1933
     - Format 2 working trees [always]
 
1934
     - Format 4 branches [always]
1935
1935
     - Format 5 repositories [always]
1936
1936
       Unhashed stores in the repository.
1937
1937
    """
1957
1957
 
1958
1958
    def _initialize_for_clone(self, url):
1959
1959
        return self.initialize_on_transport(get_transport(url), _cloning=True)
1960
 
        
 
1960
 
1961
1961
    def initialize_on_transport(self, transport, _cloning=False):
1962
1962
        """Format 5 dirs always have working tree, branch and repository.
1963
 
        
 
1963
 
1964
1964
        Except when they are being cloned.
1965
1965
        """
1966
1966
        from bzrlib.branch import BzrBranchFormat4
1988
1988
 
1989
1989
    This format is a combined format for working tree, branch and repository.
1990
1990
    It has:
1991
 
     - Format 2 working trees [always] 
1992
 
     - Format 4 branches [always] 
 
1991
     - Format 2 working trees [always]
 
1992
     - Format 4 branches [always]
1993
1993
     - Format 6 repositories [always]
1994
1994
    """
1995
1995
 
2011
2011
        """See BzrDirFormat.get_converter()."""
2012
2012
        # there is one and only one upgrade path here.
2013
2013
        return ConvertBzrDir6ToMeta()
2014
 
        
 
2014
 
2015
2015
    def _initialize_for_clone(self, url):
2016
2016
        return self.initialize_on_transport(get_transport(url), _cloning=True)
2017
2017
 
2018
2018
    def initialize_on_transport(self, transport, _cloning=False):
2019
2019
        """Format 6 dirs always have working tree, branch and repository.
2020
 
        
 
2020
 
2021
2021
        Except when they are being cloned.
2022
2022
        """
2023
2023
        from bzrlib.branch import BzrBranchFormat4
2201
2201
        self.absent_revisions = set()
2202
2202
        self.text_count = 0
2203
2203
        self.revisions = {}
2204
 
        
 
2204
 
2205
2205
    def convert(self, to_convert, pb):
2206
2206
        """See Converter.convert()."""
2207
2207
        self.bzrdir = to_convert
2313
2313
                revision_store.add_lines(key, None, osutils.split_lines(text))
2314
2314
        finally:
2315
2315
            self.pb.clear()
2316
 
            
 
2316
 
2317
2317
    def _load_one_rev(self, rev_id):
2318
2318
        """Load a revision object into memory.
2319
2319
 
2393
2393
        text_changed = False
2394
2394
        parent_candiate_entries = ie.parent_candidates(parent_invs)
2395
2395
        heads = graph.Graph(self).heads(parent_candiate_entries.keys())
2396
 
        # XXX: Note that this is unordered - and this is tolerable because 
 
2396
        # XXX: Note that this is unordered - and this is tolerable because
2397
2397
        # the previous code was also unordered.
2398
2398
        previous_entries = dict((head, parent_candiate_entries[head]) for head
2399
2399
            in heads)
2416
2416
        # a call to:. This needs the path figured out. rather than a work_tree
2417
2417
        # a v4 revision_tree can be given, or something that looks enough like
2418
2418
        # one to give the file content to the entry if it needs it.
2419
 
        # and we need something that looks like a weave store for snapshot to 
 
2419
        # and we need something that looks like a weave store for snapshot to
2420
2420
        # save against.
2421
2421
        #ie.snapshot(rev, PATH, previous_revisions, REVISION_TREE, InMemoryWeaveStore(self.text_weaves))
2422
2422
        if len(previous_revisions) == 1:
2538
2538
        self.bzrdir.transport.mkdir('repository', mode=self.dir_mode)
2539
2539
        self.make_lock('repository')
2540
2540
        # we hard code the formats here because we are converting into
2541
 
        # the meta format. The meta format upgrader can take this to a 
 
2541
        # the meta format. The meta format upgrader can take this to a
2542
2542
        # future format within each component.
2543
2543
        self.put_format('repository', RepositoryFormat7())
2544
2544
        for entry in repository_names:
2698
2698
 
2699
2699
    def get_format_description(self):
2700
2700
        return 'bzr remote bzrdir'
2701
 
    
 
2701
 
2702
2702
    @classmethod
2703
2703
    def probe_transport(klass, transport):
2704
2704
        """Return a RemoteBzrDirFormat object if it looks possible."""
2782
2782
 
2783
2783
class BzrDirFormatRegistry(registry.Registry):
2784
2784
    """Registry of user-selectable BzrDir subformats.
2785
 
    
 
2785
 
2786
2786
    Differs from BzrDirFormat._control_formats in that it provides sub-formats,
2787
2787
    e.g. BzrDirMeta1 with weave repository.  Also, it's more user-oriented.
2788
2788
    """
2847
2847
    def register(self, key, factory, help, native=True, deprecated=False,
2848
2848
                 hidden=False, experimental=False, alias=False):
2849
2849
        """Register a BzrDirFormat factory.
2850
 
        
 
2850
 
2851
2851
        The factory must be a callable that takes one parameter: the key.
2852
2852
        It must produce an instance of the BzrDirFormat when called.
2853
2853
 
2870
2870
 
2871
2871
    def set_default(self, key):
2872
2872
        """Set the 'default' key to be a clone of the supplied key.
2873
 
        
 
2873
 
2874
2874
        This method must be called once and only once.
2875
2875
        """
2876
2876
        registry.Registry.register(self, 'default', self.get(key),
2879
2879
 
2880
2880
    def set_default_repository(self, key):
2881
2881
        """Set the FormatRegistry default and Repository default.
2882
 
        
 
2882
 
2883
2883
        This is a transitional method while Repository.set_default_format
2884
2884
        is deprecated.
2885
2885
        """
2908
2908
        def wrapped(key, help, info):
2909
2909
            if info.native:
2910
2910
                help = '(native) ' + help
2911
 
            return ':%s:\n%s\n\n' % (key, 
2912
 
                    textwrap.fill(help, initial_indent='    ', 
 
2911
            return ':%s:\n%s\n\n' % (key,
 
2912
                    textwrap.fill(help, initial_indent='    ',
2913
2913
                    subsequent_indent='    '))
2914
2914
        if default_realkey is not None:
2915
2915
            output += wrapped(default_realkey, '(default) %s' % default_help,