← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

  • Committer: John Arbash Meinel
  • Date: 2007-07-13 02:23:34 UTC
  • mfrom: (2592 +trunk) (2612 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2614.
  • Revision ID: john@arbash-meinel.com-20070713022334-qb6ewgo6v4251yd9
[merge] bzr.dev 2612

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
24
23
 
25
24
from bzrlib import (
26
25
    bzrdir,
828
827
        
829
828
        This is topologically sorted.
830
829
        """
831
 
        if revision_id is None:
 
830
        if _mod_revision.is_null(revision_id):
832
831
            return [None]
833
832
        revision_id = osutils.safe_revision_id(revision_id)
834
833
        if not self.has_revision(revision_id):
837
836
        candidates = w.get_ancestry(revision_id, topo_sorted)
838
837
        return [None] + candidates # self._eliminate_revisions_not_present(candidates)
839
838
 
 
839
    def pack(self):
 
840
        """Compress the data within the repository.
 
841
 
 
842
        This operation only makes sense for some repository types. For other
 
843
        types it should be a no-op that just returns.
 
844
 
 
845
        This stub method does not require a lock, but subclasses should use
 
846
        @needs_write_lock as this is a long running call its reasonable to 
 
847
        implicitly lock for the user.
 
848
        """
 
849
 
840
850
    @needs_read_lock
841
851
    def print_file(self, file, revision_id):
842
852
        """Print `file` to stdout.
1787
1797
InterRepository.register_optimiser(InterRemoteRepository)
1788
1798
 
1789
1799
 
1790
 
class RepositoryTestProviderAdapter(object):
1791
 
    """A tool to generate a suite testing multiple repository formats at once.
1792
 
 
1793
 
    This is done by copying the test once for each transport and injecting
1794
 
    the transport_server, transport_readonly_server, and bzrdir_format and
1795
 
    repository_format classes into each copy. Each copy is also given a new id()
1796
 
    to make it easy to identify.
1797
 
    """
1798
 
 
1799
 
    def __init__(self, transport_server, transport_readonly_server, formats,
1800
 
                 vfs_transport_factory=None):
1801
 
        self._transport_server = transport_server
1802
 
        self._transport_readonly_server = transport_readonly_server
1803
 
        self._vfs_transport_factory = vfs_transport_factory
1804
 
        self._formats = formats
1805
 
    
1806
 
    def adapt(self, test):
1807
 
        result = unittest.TestSuite()
1808
 
        for repository_format, bzrdir_format in self._formats:
1809
 
            from copy import deepcopy
1810
 
            new_test = deepcopy(test)
1811
 
            new_test.transport_server = self._transport_server
1812
 
            new_test.transport_readonly_server = self._transport_readonly_server
1813
 
            # Only override the test's vfs_transport_factory if one was
1814
 
            # specified, otherwise just leave the default in place.
1815
 
            if self._vfs_transport_factory:
1816
 
                new_test.vfs_transport_factory = self._vfs_transport_factory
1817
 
            new_test.bzrdir_format = bzrdir_format
1818
 
            new_test.repository_format = repository_format
1819
 
            def make_new_test_id():
1820
 
                new_id = "%s(%s)" % (new_test.id(), repository_format.__class__.__name__)
1821
 
                return lambda: new_id
1822
 
            new_test.id = make_new_test_id()
1823
 
            result.addTest(new_test)
1824
 
        return result
1825
 
 
1826
 
 
1827
 
class InterRepositoryTestProviderAdapter(object):
1828
 
    """A tool to generate a suite testing multiple inter repository formats.
1829
 
 
1830
 
    This is done by copying the test once for each interrepo provider and injecting
1831
 
    the transport_server, transport_readonly_server, repository_format and 
1832
 
    repository_to_format classes into each copy.
1833
 
    Each copy is also given a new id() to make it easy to identify.
1834
 
    """
1835
 
 
1836
 
    def __init__(self, transport_server, transport_readonly_server, formats):
1837
 
        self._transport_server = transport_server
1838
 
        self._transport_readonly_server = transport_readonly_server
1839
 
        self._formats = formats
1840
 
    
1841
 
    def adapt(self, test):
1842
 
        result = unittest.TestSuite()
1843
 
        for interrepo_class, repository_format, repository_format_to in self._formats:
1844
 
            from copy import deepcopy
1845
 
            new_test = deepcopy(test)
1846
 
            new_test.transport_server = self._transport_server
1847
 
            new_test.transport_readonly_server = self._transport_readonly_server
1848
 
            new_test.interrepo_class = interrepo_class
1849
 
            new_test.repository_format = repository_format
1850
 
            new_test.repository_format_to = repository_format_to
1851
 
            def make_new_test_id():
1852
 
                new_id = "%s(%s)" % (new_test.id(), interrepo_class.__name__)
1853
 
                return lambda: new_id
1854
 
            new_test.id = make_new_test_id()
1855
 
            result.addTest(new_test)
1856
 
        return result
1857
 
 
1858
 
    @staticmethod
1859
 
    def default_test_list():
1860
 
        """Generate the default list of interrepo permutations to test."""
1861
 
        from bzrlib.repofmt import knitrepo, weaverepo
1862
 
        result = []
1863
 
        # test the default InterRepository between format 6 and the current 
1864
 
        # default format.
1865
 
        # XXX: robertc 20060220 reinstate this when there are two supported
1866
 
        # formats which do not have an optimal code path between them.
1867
 
        #result.append((InterRepository,
1868
 
        #               RepositoryFormat6(),
1869
 
        #               RepositoryFormatKnit1()))
1870
 
        for optimiser_class in InterRepository._optimisers:
1871
 
            format_to_test = optimiser_class._get_repo_format_to_test()
1872
 
            if format_to_test is not None:
1873
 
                result.append((optimiser_class,
1874
 
                               format_to_test, format_to_test))
1875
 
        # if there are specific combinations we want to use, we can add them 
1876
 
        # here.
1877
 
        result.append((InterModel1and2,
1878
 
                       weaverepo.RepositoryFormat5(),
1879
 
                       knitrepo.RepositoryFormatKnit3()))
1880
 
        result.append((InterKnit1and2,
1881
 
                       knitrepo.RepositoryFormatKnit1(),
1882
 
                       knitrepo.RepositoryFormatKnit3()))
1883
 
        return result
1884
 
 
1885
 
 
1886
1800
class CopyConverter(object):
1887
1801
    """A repository conversion tool which just performs a copy of the content.
1888
1802