← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

  • Committer: v.ladeuil+lp at free
  • Date: 2007-05-18 18:20:31 UTC
  • mto: (2485.8.44 bzr.connection.sharing)
  • mto: This revision was merged to the branch mainline in revision 2646.
  • Revision ID: v.ladeuil+lp@free.fr-20070518182031-gbg2cgidv5l20x9p
Takes Robert comments into account.

* bzrlib/transport/ftp.py:
(FtpTransport.__init__): Write a better explanation.

* bzrlib/tests/test_init.py:
(InstrumentedTransport): Just make hooks a class attribute.
(InstrumentedTransport._get_FTP): Run hook directly in the for
loop.
(TransportHooks.run_hook, TransportHooks.uninstall_hook): Not
needed. The hooks should be cleaned up by the test itself.
(TestInit.setUp.cleanup): Resset to default hooks.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/repository.py
20
20
lazy_import(globals(), """
21
21
import re
22
22
import time
 
23
import unittest
23
24
 
24
25
from bzrlib import (
25
26
    bzrdir,
26
27
    check,
27
 
    deprecated_graph,
28
28
    errors,
29
29
    generate_ids,
30
30
    gpg,
40
40
    transactions,
41
41
    ui,
42
42
    )
43
 
from bzrlib.bundle import serializer
44
43
from bzrlib.revisiontree import RevisionTree
45
44
from bzrlib.store.versioned import VersionedFileStore
46
45
from bzrlib.store.text import TextStore
144
143
                self.add_inventory(revision_id, inv, rev.parent_ids)
145
144
        self._revision_store.add_revision(rev, self.get_transaction())
146
145
 
147
 
    def _add_revision_text(self, revision_id, text):
148
 
        revision = self._revision_store._serializer.read_revision_from_string(
149
 
            text)
150
 
        self._revision_store._add_revision(revision, StringIO(text),
151
 
                                           self.get_transaction())
152
 
 
153
146
    @needs_read_lock
154
147
    def _all_possible_ids(self):
155
148
        """Return all the possible revisions that we could find."""
372
365
        except NotImplementedError:
373
366
            raise errors.IncompatibleRepositories(source, self)
374
367
 
375
 
    def create_bundle(self, target, base, fileobj, format=None):
376
 
        return serializer.write_bundle(self, target, base, fileobj, format)
377
 
 
378
368
    def get_commit_builder(self, branch, parents, config, timestamp=None, 
379
369
                           timezone=None, committer=None, revprops=None, 
380
370
                           revision_id=None):
653
643
    def serialise_inventory(self, inv):
654
644
        return self._serializer.write_inventory_to_string(inv)
655
645
 
656
 
    def get_serializer_format(self):
657
 
        return self._serializer.format_num
658
 
 
659
646
    @needs_read_lock
660
647
    def get_inventory_xml(self, revision_id):
661
648
        """Get inventory XML as a file object."""
716
703
        :param revision_ids: an iterable of revisions to graph or None for all.
717
704
        :return: a Graph object with the graph reachable from revision_ids.
718
705
        """
719
 
        result = deprecated_graph.Graph()
 
706
        result = graph.Graph()
720
707
        if not revision_ids:
721
708
            pending = set(self.all_revision_ids())
722
709
            required = set([])
831
818
            yield RevisionTree(self, inv, revision_id)
832
819
 
833
820
    @needs_read_lock
834
 
    def get_ancestry(self, revision_id, topo_sorted=True):
 
821
    def get_ancestry(self, revision_id):
835
822
        """Return a list of revision-ids integrated by a revision.
836
823
 
837
824
        The first element of the list is always None, indicating the origin 
840
827
        
841
828
        This is topologically sorted.
842
829
        """
843
 
        if _mod_revision.is_null(revision_id):
 
830
        if revision_id is None:
844
831
            return [None]
845
832
        revision_id = osutils.safe_revision_id(revision_id)
846
833
        if not self.has_revision(revision_id):
847
834
            raise errors.NoSuchRevision(self, revision_id)
848
835
        w = self.get_inventory_weave()
849
 
        candidates = w.get_ancestry(revision_id, topo_sorted)
 
836
        candidates = w.get_ancestry(revision_id)
850
837
        return [None] + candidates # self._eliminate_revisions_not_present(candidates)
851
838
 
852
 
    def pack(self):
853
 
        """Compress the data within the repository.
854
 
 
855
 
        This operation only makes sense for some repository types. For other
856
 
        types it should be a no-op that just returns.
857
 
 
858
 
        This stub method does not require a lock, but subclasses should use
859
 
        @needs_write_lock as this is a long running call its reasonable to 
860
 
        implicitly lock for the user.
861
 
        """
862
 
 
863
839
    @needs_read_lock
864
840
    def print_file(self, file, revision_id):
865
841
        """Print `file` to stdout.
886
862
        revision_id = osutils.safe_revision_id(revision_id)
887
863
        return self.get_inventory_weave().parent_names(revision_id)
888
864
 
889
 
    def get_parents(self, revision_ids):
890
 
        """See StackedParentsProvider.get_parents"""
891
 
        parents_list = []
892
 
        for revision_id in revision_ids:
893
 
            if revision_id == _mod_revision.NULL_REVISION:
894
 
                parents = []
895
 
            else:
896
 
                try:
897
 
                    parents = self.get_revision(revision_id).parent_ids
898
 
                except errors.NoSuchRevision:
899
 
                    parents = None
900
 
                else:
901
 
                    if len(parents) == 0:
902
 
                        parents = [_mod_revision.NULL_REVISION]
903
 
            parents_list.append(parents)
904
 
        return parents_list
905
 
 
906
 
    def _make_parents_provider(self):
907
 
        return self
908
 
 
909
 
    def get_graph(self, other_repository=None):
910
 
        """Return the graph walker for this repository format"""
911
 
        parents_provider = self._make_parents_provider()
912
 
        if (other_repository is not None and
913
 
            other_repository.bzrdir.transport.base !=
914
 
            self.bzrdir.transport.base):
915
 
            parents_provider = graph._StackedParentsProvider(
916
 
                [parents_provider, other_repository._make_parents_provider()])
917
 
        return graph.Graph(parents_provider)
918
 
 
919
865
    @needs_write_lock
920
866
    def set_make_working_trees(self, new_value):
921
867
        """Set the policy flag for making working trees when creating branches.
1810
1756
InterRepository.register_optimiser(InterRemoteRepository)
1811
1757
 
1812
1758
 
 
1759
class RepositoryTestProviderAdapter(object):
 
1760
    """A tool to generate a suite testing multiple repository formats at once.
 
1761
 
 
1762
    This is done by copying the test once for each transport and injecting
 
1763
    the transport_server, transport_readonly_server, and bzrdir_format and
 
1764
    repository_format classes into each copy. Each copy is also given a new id()
 
1765
    to make it easy to identify.
 
1766
    """
 
1767
 
 
1768
    def __init__(self, transport_server, transport_readonly_server, formats,
 
1769
                 vfs_transport_factory=None):
 
1770
        self._transport_server = transport_server
 
1771
        self._transport_readonly_server = transport_readonly_server
 
1772
        self._vfs_transport_factory = vfs_transport_factory
 
1773
        self._formats = formats
 
1774
    
 
1775
    def adapt(self, test):
 
1776
        result = unittest.TestSuite()
 
1777
        for repository_format, bzrdir_format in self._formats:
 
1778
            from copy import deepcopy
 
1779
            new_test = deepcopy(test)
 
1780
            new_test.transport_server = self._transport_server
 
1781
            new_test.transport_readonly_server = self._transport_readonly_server
 
1782
            # Only override the test's vfs_transport_factory if one was
 
1783
            # specified, otherwise just leave the default in place.
 
1784
            if self._vfs_transport_factory:
 
1785
                new_test.vfs_transport_factory = self._vfs_transport_factory
 
1786
            new_test.bzrdir_format = bzrdir_format
 
1787
            new_test.repository_format = repository_format
 
1788
            def make_new_test_id():
 
1789
                new_id = "%s(%s)" % (new_test.id(), repository_format.__class__.__name__)
 
1790
                return lambda: new_id
 
1791
            new_test.id = make_new_test_id()
 
1792
            result.addTest(new_test)
 
1793
        return result
 
1794
 
 
1795
 
 
1796
class InterRepositoryTestProviderAdapter(object):
 
1797
    """A tool to generate a suite testing multiple inter repository formats.
 
1798
 
 
1799
    This is done by copying the test once for each interrepo provider and injecting
 
1800
    the transport_server, transport_readonly_server, repository_format and 
 
1801
    repository_to_format classes into each copy.
 
1802
    Each copy is also given a new id() to make it easy to identify.
 
1803
    """
 
1804
 
 
1805
    def __init__(self, transport_server, transport_readonly_server, formats):
 
1806
        self._transport_server = transport_server
 
1807
        self._transport_readonly_server = transport_readonly_server
 
1808
        self._formats = formats
 
1809
    
 
1810
    def adapt(self, test):
 
1811
        result = unittest.TestSuite()
 
1812
        for interrepo_class, repository_format, repository_format_to in self._formats:
 
1813
            from copy import deepcopy
 
1814
            new_test = deepcopy(test)
 
1815
            new_test.transport_server = self._transport_server
 
1816
            new_test.transport_readonly_server = self._transport_readonly_server
 
1817
            new_test.interrepo_class = interrepo_class
 
1818
            new_test.repository_format = repository_format
 
1819
            new_test.repository_format_to = repository_format_to
 
1820
            def make_new_test_id():
 
1821
                new_id = "%s(%s)" % (new_test.id(), interrepo_class.__name__)
 
1822
                return lambda: new_id
 
1823
            new_test.id = make_new_test_id()
 
1824
            result.addTest(new_test)
 
1825
        return result
 
1826
 
 
1827
    @staticmethod
 
1828
    def default_test_list():
 
1829
        """Generate the default list of interrepo permutations to test."""
 
1830
        from bzrlib.repofmt import knitrepo, weaverepo
 
1831
        result = []
 
1832
        # test the default InterRepository between format 6 and the current 
 
1833
        # default format.
 
1834
        # XXX: robertc 20060220 reinstate this when there are two supported
 
1835
        # formats which do not have an optimal code path between them.
 
1836
        #result.append((InterRepository,
 
1837
        #               RepositoryFormat6(),
 
1838
        #               RepositoryFormatKnit1()))
 
1839
        for optimiser_class in InterRepository._optimisers:
 
1840
            format_to_test = optimiser_class._get_repo_format_to_test()
 
1841
            if format_to_test is not None:
 
1842
                result.append((optimiser_class,
 
1843
                               format_to_test, format_to_test))
 
1844
        # if there are specific combinations we want to use, we can add them 
 
1845
        # here.
 
1846
        result.append((InterModel1and2,
 
1847
                       weaverepo.RepositoryFormat5(),
 
1848
                       knitrepo.RepositoryFormatKnit3()))
 
1849
        result.append((InterKnit1and2,
 
1850
                       knitrepo.RepositoryFormatKnit1(),
 
1851
                       knitrepo.RepositoryFormatKnit3()))
 
1852
        return result
 
1853
 
 
1854
 
1813
1855
class CopyConverter(object):
1814
1856
    """A repository conversion tool which just performs a copy of the content.
1815
1857