[MERGE] Add a smart method method that can pull a set of revisions in a single request

[Andrew Bennetts]

Aaron Bentley wrote:
> Aaron Bentley has voted resubmit.
> Status is now: Resubmit
> Comment:
> I believe this will introduce regressions when pulling from repositories 
> with broken last-modified data, because it doesn't emulate 
> iter_file_revisions_aggressive.

Ok.  This version adds some simple sanity checking of the data it's inserting.
I've borrowed your 'make_broken_repository' test helper to do that.  We'll want
to tidy up that duplication when these branches have both landed.

Other changes since the previous iteration:
  * use tuples for names in the packs, rather than colon-delimited strings
  * renamed the smart method to “Repository.stream_knit_data_for_revisions”
  * fixed a bug or two.

I've been dogfooding this branch for a fair while now, and so far nothing has
exploded :)

-Andrew.

-------------- next part --------------
# Bazaar merge directive format 2 (Bazaar 0.90)
# revision_id: andrew.bennetts at canonical.com-20070831054346-\
#   lhocj4hvyzyn2hqc
# target_branch: http://bazaar-vcs.org/bzr/bzr.dev
# testament_sha1: f385ab81c9350780e048d740a763b1fdd6a9a008
# timestamp: 2007-08-31 15:44:03 +1000
# source_branch: http://people.ubuntu.com/~andrew/bzr/repo-refactor
# base_revision_id: pqm at pqm.ubuntu.com-20070831020510-emrlta5dk6ta95zp
# 
# Begin patch
=== modified file 'bzrlib/errors.py'
--- bzrlib/errors.py	2007-08-30 08:11:54 +0000
+++ bzrlib/errors.py	2007-08-30 08:32:34 +0000
@@ -2350,6 +2350,14 @@
     internal_error = True
 
 
+class RepositoryDataStreamError(BzrError):
+
+    _fmt = "Corrupt or incompatible data stream: %(reason)s"
+
+    def __init__(self, reason):
+        self.reason = reason
+
+
 class SMTPError(BzrError):
 
     _fmt = "SMTP error: %(error)s"

=== modified file 'bzrlib/fetch.py'
--- bzrlib/fetch.py	2007-08-22 22:30:11 +0000
+++ bzrlib/fetch.py	2007-08-31 05:43:46 +0000
@@ -128,14 +128,14 @@
         try:
             pp.next_phase()
             revs = self._revids_to_fetch()
+            if revs is None:
+                return
             self._fetch_everything_for_revisions(revs, pp)
         finally:
             self.pb.clear()
 
     def _fetch_everything_for_revisions(self, revs, pp):
         """Fetch all data for the given set of revisions."""
-        if revs is None:
-            return
         # The first phase is "file".  We pass the progress bar for it directly
         # into item_keys_introduced_by, which has more information about how
         # that phase is progressing than we do.  Progress updates for the other
@@ -194,6 +194,8 @@
             return None
             
         try:
+            # XXX: this gets the full graph on both sides, and will make sure
+            # that ghosts are filled whether or not you care about them.
             return self.to_repository.missing_revision_ids(self.from_repository,
                                                            self._last_revision)
         except errors.NoSuchRevision:
@@ -398,3 +400,12 @@
 
     def _fetch_inventory_weave(self, revs, pb):
         self.helper.regenerate_inventory(revs)
+        
+
+class RemoteToOtherFetcher(GenericRepoFetcher):
+    
+    def _fetch_everything_for_revisions(self, revs, pp):
+        data_stream = self.from_repository.get_data_stream(revs)
+        self.to_repository.insert_data_stream(data_stream)
+
+

=== modified file 'bzrlib/knit.py'
--- bzrlib/knit.py	2007-08-31 02:05:10 +0000
+++ bzrlib/knit.py	2007-08-31 05:24:34 +0000
@@ -741,6 +741,16 @@
                     raise KnitCorrupt(
                         self.filename, 'sha-1 does not match %s' % version_id)
             else:
+                if 'line-delta' in options:
+                    # Make sure that this knit record is actually useful.
+                    # Fetching from a broken repository shouldn't break the
+                    # target repository.
+                    for parent in parents:
+                        if not self._index.has_version(parent):
+                            raise KnitCorrupt(
+                                self.filename,
+                                'line-delta from stream references '
+                                'missing parent %s' % parent)
                 self._add_raw_records(
                     [(version_id, options, parents, length)],
                     reader_callable(length))

=== modified file 'bzrlib/remote.py'
--- bzrlib/remote.py	2007-08-22 05:28:32 +0000
+++ bzrlib/remote.py	2007-08-28 05:17:06 +0000
@@ -31,6 +31,7 @@
 from bzrlib.decorators import needs_read_lock, needs_write_lock
 from bzrlib.errors import NoSuchRevision
 from bzrlib.lockable_files import LockableFiles
+from bzrlib.pack import ContainerReader
 from bzrlib.revision import NULL_REVISION
 from bzrlib.smart import client, vfs
 from bzrlib.symbol_versioning import (
@@ -519,9 +520,9 @@
 
     def sprout(self, to_bzrdir, revision_id=None):
         # TODO: Option to control what format is created?
-        to_repo = to_bzrdir.create_repository()
-        self._copy_repository_tarball(to_repo, revision_id)
-        return to_repo
+        dest_repo = to_bzrdir.create_repository()
+        dest_repo.fetch(self, revision_id=revision_id)
+        return dest_repo
 
     ### These methods are just thin shims to the VFS object for now.
 
@@ -750,6 +751,35 @@
         self._ensure_real()
         return self._real_repository.has_signature_for_revision_id(revision_id)
 
+    def get_data_stream(self, revision_ids):
+        path = self.bzrdir._path_for_remote_call(self._client)
+        response, protocol = self._client.call_expecting_body(
+            'Repository.stream_knit_data_for_revisions', path, *revision_ids)
+        if response == ('ok',):
+            buffer = StringIO(protocol.read_body_bytes())
+            reader = ContainerReader(buffer)
+            for record_names, read_bytes in reader.iter_records():
+                try:
+                    # These records should have only one name, and that name
+                    # should be a one-element tuple.
+                    [name_tuple] = record_names
+                except ValueError:
+                    raise errors.SmartProtocolError(
+                        'Repository data stream had invalid record name %r'
+                        % (record_names,))
+                yield name_tuple, read_bytes(None)
+        else:
+            raise errors.UnexpectedSmartServerResponse(response)
+
+    def insert_data_stream(self, stream):
+        self._ensure_real()
+        self._real_repository.insert_data_stream(stream)
+
+    def item_keys_introduced_by(self, revision_ids, _files_pb=None):
+        self._ensure_real()
+        return self._real_repository.item_keys_introduced_by(revision_ids,
+            _files_pb=_files_pb)
+
 
 class RemoteBranchLockableFiles(LockableFiles):
     """A 'LockableFiles' implementation that talks to a smart server.

=== modified file 'bzrlib/repofmt/knitrepo.py'
--- bzrlib/repofmt/knitrepo.py	2007-08-30 08:27:29 +0000
+++ bzrlib/repofmt/knitrepo.py	2007-08-31 05:43:46 +0000
@@ -128,6 +128,27 @@
             raise errors.NoSuchRevision(self, revision_id)
 
     @needs_read_lock
+    def get_data_stream(self, revision_ids):
+        """See Repository.get_data_stream."""
+        for knit_kind, file_id, versions in self.item_keys_introduced_by(revision_ids):
+            name = (knit_kind,)
+            if knit_kind == 'file':
+                name = ('file', file_id)
+                knit = self.weave_store.get_weave_or_empty(
+                    file_id, self.get_transaction())
+            elif knit_kind == 'inventory':
+                knit = self.get_inventory_weave()
+            elif knit_kind == 'revisions':
+                knit = self._revision_store.get_revision_file(
+                    self.get_transaction())
+            elif knit_kind == 'signatures':
+                knit = self._revision_store.get_signature_file(
+                    self.get_transaction())
+            else:
+                raise AssertionError('Unknown knit kind %r' % (knit_kind,))
+            yield name, _get_stream_as_bytes(knit, versions)
+
+    @needs_read_lock
     def get_revision(self, revision_id):
         """Return the Revision object for a named revision"""
         revision_id = osutils.safe_revision_id(revision_id)

=== modified file 'bzrlib/repository.py'
--- bzrlib/repository.py	2007-08-28 01:58:42 +0000
+++ bzrlib/repository.py	2007-08-30 01:45:33 +0000
@@ -46,6 +46,7 @@
 from bzrlib.store.versioned import VersionedFileStore
 from bzrlib.store.text import TextStore
 from bzrlib.testament import Testament
+from bzrlib.util import bencode
 """)
 
 from bzrlib.decorators import needs_read_lock, needs_write_lock
@@ -382,6 +383,36 @@
             result['size'] = t
         return result
 
+    def get_data_stream(self, revision_ids):
+        raise NotImplementedError(self.get_data_stream)
+
+    def insert_data_stream(self, stream):
+        for item_key, bytes in stream:
+            if item_key[0] == 'file':
+                (file_id,) = item_key[1:]
+                knit = self.weave_store.get_weave_or_empty(
+                    file_id, self.get_transaction())
+            elif item_key == ('inventory',):
+                knit = self.get_inventory_weave()
+            elif item_key == ('revisions',):
+                knit = self._revision_store.get_revision_file(
+                    self.get_transaction())
+            elif item_key == ('signatures',):
+                knit = self._revision_store.get_signature_file(
+                    self.get_transaction())
+            else:
+                raise RepositoryDataStreamError(
+                    "Unrecognised data stream key '%s'" % (item_key,))
+            decoded_list = bencode.bdecode(bytes)
+            format = decoded_list.pop(0)
+            data_list = []
+            knit_bytes = ''
+            for version, options, parents, some_bytes in decoded_list:
+                data_list.append((version, options, len(some_bytes), parents))
+                knit_bytes += some_bytes
+            knit.insert_data_stream(
+                (format, data_list, StringIO(knit_bytes).read))
+
     @needs_read_lock
     def missing_revision_ids(self, other, revision_id=None):
         """Return the revision ids that other has that this does not.
@@ -778,6 +809,7 @@
         # maybe this generator should explicitly have the contract that it
         # should not be iterated until the previously yielded item has been
         # processed?
+        self.lock_read()
         inv_w = self.get_inventory_weave()
         inv_w.enable_cache()
 
@@ -808,6 +840,7 @@
                 pass
             else:
                 revisions_with_signatures.add(rev_id)
+        self.unlock()
         yield ("signatures", None, revisions_with_signatures)
 
         # revisions
@@ -1967,39 +2000,69 @@
         return f.count_copied, f.failed_revisions
 
 
-class InterRemoteRepository(InterRepository):
-    """Code for converting between RemoteRepository objects.
-
-    This just gets an non-remote repository from the RemoteRepository, and calls
-    InterRepository.get again.
-    """
-
-    def __init__(self, source, target):
-        if isinstance(source, remote.RemoteRepository):
-            source._ensure_real()
-            real_source = source._real_repository
-        else:
-            real_source = source
-        if isinstance(target, remote.RemoteRepository):
-            target._ensure_real()
-            real_target = target._real_repository
-        else:
-            real_target = target
-        self.real_inter = InterRepository.get(real_source, real_target)
-
-    @staticmethod
-    def is_compatible(source, target):
-        if isinstance(source, remote.RemoteRepository):
-            return True
+class InterRemoteToOther(InterRepository):
+
+    def __init__(self, source, target):
+        InterRepository.__init__(self, source, target)
+        self._real_inter = None
+
+    @staticmethod
+    def is_compatible(source, target):
+        if not isinstance(source, remote.RemoteRepository):
+            return False
+        source._ensure_real()
+        real_source = source._real_repository
+        # Is source's model compatible with target's model, and are they the
+        # same format?  Currently we can only optimise fetching from an
+        # identical model & format repo.
+        assert not isinstance(real_source, remote.RemoteRepository), (
+            "We don't support remote repos backed by remote repos yet.")
+        return real_source._format == target._format
+
+    @needs_write_lock
+    def fetch(self, revision_id=None, pb=None):
+        """See InterRepository.fetch()."""
+        from bzrlib.fetch import RemoteToOtherFetcher
+        mutter("Using fetch logic to copy between %s(remote) and %s(%s)",
+               self.source, self.target, self.target._format)
+        # TODO: jam 20070210 This should be an assert, not a translate
+        revision_id = osutils.safe_revision_id(revision_id)
+        f = RemoteToOtherFetcher(to_repository=self.target,
+                                 from_repository=self.source,
+                                 last_revision=revision_id,
+                                 pb=pb)
+        return f.count_copied, f.failed_revisions
+
+    @classmethod
+    def _get_repo_format_to_test(self):
+        return None
+
+
+class InterOtherToRemote(InterRepository):
+
+    def __init__(self, source, target):
+        InterRepository.__init__(self, source, target)
+        self._real_inter = None
+
+    @staticmethod
+    def is_compatible(source, target):
         if isinstance(target, remote.RemoteRepository):
             return True
         return False
 
+    def _ensure_real_inter(self):
+        if self._real_inter is None:
+            self.target._ensure_real()
+            real_target = self.target._real_repository
+            self._real_inter = InterRepository.get(self.source, real_target)
+    
     def copy_content(self, revision_id=None):
-        self.real_inter.copy_content(revision_id=revision_id)
+        self._ensure_real_inter()
+        self._real_inter.copy_content(revision_id=revision_id)
 
     def fetch(self, revision_id=None, pb=None):
-        self.real_inter.fetch(revision_id=revision_id, pb=pb)
+        self._ensure_real_inter()
+        self._real_inter.fetch(revision_id=revision_id, pb=pb)
 
     @classmethod
     def _get_repo_format_to_test(self):
@@ -2011,7 +2074,8 @@
 InterRepository.register_optimiser(InterKnitRepo)
 InterRepository.register_optimiser(InterModel1and2)
 InterRepository.register_optimiser(InterKnit1and2)
-InterRepository.register_optimiser(InterRemoteRepository)
+InterRepository.register_optimiser(InterRemoteToOther)
+InterRepository.register_optimiser(InterOtherToRemote)
 
 
 class CopyConverter(object):

=== modified file 'bzrlib/smart/repository.py'
--- bzrlib/smart/repository.py	2007-07-19 06:34:09 +0000
+++ bzrlib/smart/repository.py	2007-08-23 08:00:08 +0000
@@ -16,6 +16,7 @@
 
 """Server-side repository related request implmentations."""
 
+from cStringIO import StringIO
 import os
 import sys
 import tempfile
@@ -23,6 +24,7 @@
 
 from bzrlib import errors
 from bzrlib.bzrdir import BzrDir
+from bzrlib.pack import ContainerWriter
 from bzrlib.smart.request import (
     FailedSmartServerResponse,
     SmartServerRequest,
@@ -239,3 +241,20 @@
             tarball.add(dirname, '.bzr') # recursive by default
         finally:
             tarball.close()
+
+
+class SmartServerRepositoryStreamKnitDataForRevisions(SmartServerRepositoryRequest):
+
+    def do_repository_request(self, repository, *revision_ids):
+        stream = repository.get_data_stream(revision_ids)
+        filelike = StringIO()
+        pack = ContainerWriter(filelike.write)
+        pack.begin()
+        try:
+            for name_tuple, bytes in stream:
+                pack.add_bytes_record(bytes, [name_tuple])
+        except errors.RevisionNotPresent, e:
+            return FailedSmartServerResponse(('NoSuchRevision', e.revision_id))
+        pack.end()
+        return SuccessfulSmartServerResponse(('ok',), filelike.getvalue())
+

=== modified file 'bzrlib/smart/request.py'
--- bzrlib/smart/request.py	2007-04-26 09:07:38 +0000
+++ bzrlib/smart/request.py	2007-08-22 07:16:39 +0000
@@ -306,6 +306,8 @@
                                'bzrlib.smart.repository',
                                'SmartServerRepositoryGatherStats')
 request_handlers.register_lazy(
+    'Repository.stream_knit_data_for_revisions', 'bzrlib.smart.repository', 'SmartServerRepositoryStreamKnitDataForRevisions')
+request_handlers.register_lazy(
     'Repository.get_revision_graph', 'bzrlib.smart.repository', 'SmartServerRepositoryGetRevisionGraph')
 request_handlers.register_lazy(
     'Repository.has_revision', 'bzrlib.smart.repository', 'SmartServerRequestHasRevision')

=== modified file 'bzrlib/tests/repository_implementations/test_fetch.py'
--- bzrlib/tests/repository_implementations/test_fetch.py	2007-08-20 07:54:29 +0000
+++ bzrlib/tests/repository_implementations/test_fetch.py	2007-08-21 23:55:35 +0000
@@ -92,3 +92,19 @@
         self.assertEqual(
             source_repo.get_signature_text('rev1'),
             target_repo.get_signature_text('rev1'))
+
+    def make_repository_with_one_revision(self):
+        wt = self.make_branch_and_tree('source', '')
+        wt.commit('rev1', allow_pointless=True, rev_id='rev1')
+        return wt.branch.repository
+
+    def test_fetch_revision_already_exists(self):
+        # Make a repository with one revision.
+        source_repo = self.make_repository_with_one_revision()
+        # Fetch that revision into a second repository.
+        target_repo = self.make_repository('target')
+        target_repo.fetch(source_repo, revision_id='rev1')
+        # Now fetch again; there will be nothing to do.  This should work
+        # without causing any errors.
+        target_repo.fetch(source_repo, revision_id='rev1')
+

=== modified file 'bzrlib/tests/repository_implementations/test_repository.py'
--- bzrlib/tests/repository_implementations/test_repository.py	2007-08-21 03:40:50 +0000
+++ bzrlib/tests/repository_implementations/test_repository.py	2007-08-23 08:00:08 +0000
@@ -370,6 +370,67 @@
         repo._format.rich_root_data
         repo._format.supports_tree_reference
 
+    def test_get_data_stream(self):
+        # Make a repo with a revision
+        tree = self.make_branch_and_tree('t')
+        self.build_tree(['t/foo'])
+        tree.add('foo', 'file1')
+        tree.commit('message', rev_id='rev_id')
+        repo = tree.branch.repository
+
+        # Get a data stream (a file-like object) for that revision
+        try:
+            stream = repo.get_data_stream(['rev_id'])
+        except NotImplementedError:
+            # Not all repositories support streaming.
+            return
+
+        # The data stream is a iterator that yields (name, versioned_file)
+        # pairs for:
+        #   * the file knit (or knits; if this repo has rich roots there will be
+        #     a file knit for that as well as for 'file1').
+        #   * the inventory knit
+        #   * the revisions knit
+        # in that order.
+        expected_record_names = [
+            ('file', 'file1'),
+            ('inventory',),
+            ('signatures',),
+            ('revisions',)]
+        streamed_names = []
+        for name, bytes in stream:
+            streamed_names.append(name)
+
+        if repo.supports_rich_root():
+            # Check for the root versioned file in the stream, then remove it
+            # from streamed_names so we can compare that with
+            # expected_record_names.
+            # Note that the file knits can be in any order, so this test is
+            # written to allow that.
+            inv = repo.get_inventory('rev_id')
+            expected_record_name = ('file', inv.root.file_id)
+            self.assertTrue(expected_record_name in streamed_names)
+            streamed_names.remove(expected_record_name)
+
+        self.assertEqual(expected_record_names, streamed_names)
+
+    def test_insert_data_stream(self):
+        tree = self.make_branch_and_tree('source')
+        self.build_tree(['source/foo'])
+        tree.add('foo', 'file1')
+        tree.commit('message', rev_id='rev_id')
+        source_repo = tree.branch.repository
+        dest_repo = self.make_repository('dest')
+        try:
+            stream = source_repo.get_data_stream(['rev_id'])
+        except NotImplementedError, e:
+            # Not all repositories support streaming.
+            self.assertContainsRe(str(e), 'get_data_stream')
+            raise TestSkipped('This format does not support streaming.')
+
+        dest_repo.insert_data_stream(stream)
+        self.assertTrue(dest_repo.has_revision('rev_id'))
+
     def test_get_serializer_format(self):
         repo = self.make_repository('.')
         format = repo.get_serializer_format()

=== modified file 'bzrlib/tests/test_errors.py'
--- bzrlib/tests/test_errors.py	2007-08-30 08:11:54 +0000
+++ bzrlib/tests/test_errors.py	2007-08-30 08:32:34 +0000
@@ -362,6 +362,12 @@
             "Container has multiple records with the same name: n\xc3\xa5me",
             str(e))
 
+    def test_repository_data_stream_error(self):
+        """Test the formatting of RepositoryDataStreamError."""
+        e = errors.RepositoryDataStreamError(u"my reason")
+        self.assertEqual(
+            "Corrupt or incompatible data stream: my reason", str(e))
+
 
 class PassThroughError(errors.BzrError):
     

=== modified file 'bzrlib/tests/test_remote.py'
--- bzrlib/tests/test_remote.py	2007-07-19 06:34:09 +0000
+++ bzrlib/tests/test_remote.py	2007-08-23 08:00:08 +0000
@@ -28,6 +28,7 @@
 from bzrlib import (
     bzrdir,
     errors,
+    pack,
     remote,
     repository,
     tests,
@@ -733,24 +734,6 @@
         finally:
             tarball_file.close()
 
-    def test_sprout_uses_tarball(self):
-        # RemoteRepository.sprout should try to use the
-        # tarball command rather than accessing all the files
-        transport_path = 'srcrepo'
-        expected_responses = [(('ok',), self.tarball_content),
-            ]
-        expected_calls = [('call2', 'Repository.tarball', ('///srcrepo/', 'bz2',),),
-            ]
-        remote_repo, client = self.setup_fake_client_and_repository(
-            expected_responses, transport_path)
-        # make a regular local repository to receive the results
-        dest_transport = MemoryTransport()
-        dest_transport.mkdir('destrepo')
-        bzrdir_format = bzrdir.format_registry.make_bzrdir('default')
-        dest_bzrdir = bzrdir_format.initialize_on_transport(dest_transport)
-        # try to copy...
-        remote_repo.sprout(dest_bzrdir)
-
 
 class TestRemoteRepositoryCopyContent(tests.TestCaseWithTransport):
     """RemoteRepository.copy_content_into optimizations"""
@@ -769,3 +752,33 @@
         self.assertFalse(isinstance(dest_repo, RemoteRepository))
         self.assertTrue(isinstance(src_repo, RemoteRepository))
         src_repo.copy_content_into(dest_repo)
+
+
+class TestRepositoryStreamKnitData(TestRemoteRepository):
+
+    def make_pack_file(self, records):
+        pack_file = StringIO()
+        pack_writer = pack.ContainerWriter(pack_file.write)
+        pack_writer.begin()
+        for bytes, names in records:
+            pack_writer.add_bytes_record(bytes, names)
+        pack_writer.end()
+        pack_file.seek(0)
+        return pack_file
+
+    def test_bad_pack_from_server(self):
+        """A response with invalid data (e.g. it has a record with multiple
+        names) triggers an exception.
+        
+        Not all possible errors will be caught at this stage, but obviously
+        malformed data should be.
+        """
+        record = ('bytes', [('name1',), ('name2',)])
+        pack_file = self.make_pack_file([record])
+        responses = [(('ok',), pack_file.getvalue()), ]
+        transport_path = 'quack'
+        repo, client = self.setup_fake_client_and_repository(
+            responses, transport_path)
+        stream = repo.get_data_stream(['revid'])
+        self.assertRaises(errors.SmartProtocolError, list, stream)
+    

=== modified file 'bzrlib/tests/test_repository.py'
--- bzrlib/tests/test_repository.py	2007-08-30 08:27:29 +0000
+++ bzrlib/tests/test_repository.py	2007-08-31 05:22:46 +0000
@@ -25,16 +25,14 @@
 from stat import S_ISDIR
 from StringIO import StringIO
 
-from bzrlib import symbol_versioning
 import bzrlib
-import bzrlib.bzrdir as bzrdir
-import bzrlib.errors as errors
 from bzrlib.errors import (NotBranchError,
                            NoSuchFile,
                            UnknownFormatError,
                            UnsupportedFormatError,
                            )
 from bzrlib.repository import RepositoryFormat
+from bzrlib.smart import server
 from bzrlib.tests import (
     TestCase,
     TestCaseWithTransport,
@@ -44,7 +42,12 @@
 from bzrlib.transport.memory import MemoryServer
 from bzrlib.util import bencode
 from bzrlib import (
+    bzrdir,
+    errors,
+    inventory,
     repository,
+    revision as _mod_revision,
+    symbol_versioning,
     upgrade,
     workingtree,
     )
@@ -513,6 +516,45 @@
                                                         repo_b).__class__)
 
 
+class TestInterRemoteToOther(TestCaseWithTransport):
+
+    def make_remote_repository(self, path, backing_format=None):
+        """Make a RemoteRepository object backed by a real repository that will
+        be created at the given path."""
+        self.make_repository(path, format=backing_format)
+        smart_server = server.SmartTCPServer_for_testing()
+        smart_server.setUp()
+        remote_transport = get_transport(smart_server.get_url()).clone(path)
+        self.addCleanup(smart_server.tearDown)
+        remote_bzrdir = bzrdir.BzrDir.open_from_transport(remote_transport)
+        remote_repo = remote_bzrdir.open_repository()
+        return remote_repo
+
+    def test_is_compatible_same_format(self):
+        """InterRemoteToOther is compatible with a remote repository and a
+        second repository that have the same format."""
+        local_repo = self.make_repository('local')
+        remote_repo = self.make_remote_repository('remote')
+        self.assertTrue(
+            repository.InterRemoteToOther.is_compatible(remote_repo, local_repo),
+            "InterRemoteToOther(%r, %r) is false" % (remote_repo, local_repo))
+          
+    def test_is_incompatible_different_format(self):
+        local_repo = self.make_repository('local', 'dirstate')
+        remote_repo = self.make_remote_repository('a', 'dirstate-with-subtree')
+        self.assertFalse(
+            repository.InterRemoteToOther.is_compatible(local_repo, remote_repo),
+            "InterRemoteToOther(%r, %r) is true" % (local_repo, remote_repo))
+
+    def test_is_incompatible_different_format_both_remote(self):
+        remote_repo_a = self.make_remote_repository('a', 'dirstate-with-subtree')
+        remote_repo_b = self.make_remote_repository('b', 'dirstate')
+        self.assertFalse(
+            repository.InterRemoteToOther.is_compatible(remote_repo_a,
+                remote_repo_b),
+            "InterRemoteToOther(%r, %r) is true" % (remote_repo_a, remote_repo_b))
+
+
 class TestRepositoryConverter(TestCaseWithTransport):
 
     def test_convert_empty(self):
@@ -559,3 +601,86 @@
         revision_tree = tree.branch.repository.revision_tree('dull2')
         self.assertEqual('dull', revision_tree.inventory.root.revision)
 
+
+class TestWithBrokenRepo(TestCaseWithTransport):
+
+    def make_broken_repository(self):
+        # XXX: This function is borrowed from Aaron's "Reconcile can fix bad
+        # parent references" branch which is due to land in bzr.dev soon.  Once
+        # it does, this duplication should be removed.
+        repo = self.make_repository('broken-repo')
+        cleanups = []
+        try:
+            repo.lock_write()
+            cleanups.append(repo.unlock)
+            repo.start_write_group()
+            cleanups.append(repo.commit_write_group)
+            # make rev1a: A well-formed revision, containing 'file1'
+            inv = inventory.Inventory(revision_id='rev1a')
+            inv.root.revision = 'rev1a'
+            self.add_file(repo, inv, 'file1', 'rev1a', [])
+            repo.add_inventory('rev1a', inv, [])
+            revision = _mod_revision.Revision('rev1a',
+                committer='jrandom at example.com', timestamp=0,
+                inventory_sha1='', timezone=0, message='foo', parent_ids=[])
+            repo.add_revision('rev1a',revision, inv)
+
+            # make rev1b, which has no Revision, but has an Inventory, and
+            # file1
+            inv = inventory.Inventory(revision_id='rev1b')
+            inv.root.revision = 'rev1b'
+            self.add_file(repo, inv, 'file1', 'rev1b', [])
+            repo.add_inventory('rev1b', inv, [])
+
+            # make rev2, with file1 and file2
+            # file2 is sane
+            # file1 has 'rev1b' as an ancestor, even though this is not
+            # mentioned by 'rev1a', making it an unreferenced ancestor
+            inv = inventory.Inventory()
+            self.add_file(repo, inv, 'file1', 'rev2', ['rev1a', 'rev1b'])
+            self.add_file(repo, inv, 'file2', 'rev2', [])
+            self.add_revision(repo, 'rev2', inv, ['rev1a'])
+
+            # make ghost revision rev1c
+            inv = inventory.Inventory()
+            self.add_file(repo, inv, 'file2', 'rev1c', [])
+
+            # make rev3 with file2
+            # file2 refers to 'rev1c', which is a ghost in this repository, so
+            # file2 cannot have rev1c as its ancestor.
+            inv = inventory.Inventory()
+            self.add_file(repo, inv, 'file2', 'rev3', ['rev1c'])
+            self.add_revision(repo, 'rev3', inv, ['rev1c'])
+            return repo
+        finally:
+            for cleanup in reversed(cleanups):
+                cleanup()
+
+    def add_revision(self, repo, revision_id, inv, parent_ids):
+        inv.revision_id = revision_id
+        inv.root.revision = revision_id
+        repo.add_inventory(revision_id, inv, parent_ids)
+        revision = _mod_revision.Revision(revision_id,
+            committer='jrandom at example.com', timestamp=0, inventory_sha1='',
+            timezone=0, message='foo', parent_ids=parent_ids)
+        repo.add_revision(revision_id,revision, inv)
+
+    def add_file(self, repo, inv, filename, revision, parents):
+        file_id = filename + '-id'
+        entry = inventory.InventoryFile(file_id, filename, 'TREE_ROOT')
+        entry.revision = revision
+        inv.add(entry)
+        vf = repo.weave_store.get_weave_or_empty(file_id,
+                                                 repo.get_transaction())
+        vf.add_lines(revision, parents, ['line\n'])
+
+    def test_insert_from_broken_repo(self):
+        """Inserting a data stream from a broken repository won't silently
+        corrupt the target repository.
+        """
+        broken_repo = self.make_broken_repository()
+        empty_repo = self.make_repository('empty-repo')
+        stream = broken_repo.get_data_stream(['rev1a', 'rev2', 'rev3'])
+        self.assertRaises(
+            errors.KnitCorrupt, empty_repo.insert_data_stream, stream)
+

=== modified file 'bzrlib/tests/test_smart.py'
--- bzrlib/tests/test_smart.py	2007-07-17 06:57:01 +0000
+++ bzrlib/tests/test_smart.py	2007-08-22 07:16:39 +0000
@@ -20,11 +20,12 @@
 import tempfile
 import tarfile
 
-from bzrlib import bzrdir, errors, smart, tests
+from bzrlib import bzrdir, errors, pack, smart, tests
 from bzrlib.smart.request import SmartServerResponse
 import bzrlib.smart.bzrdir
 import bzrlib.smart.branch
 import bzrlib.smart.repository
+from bzrlib.util import bencode
 
 
 class TestCaseWithSmartMedium(tests.TestCaseWithTransport):
@@ -766,6 +767,44 @@
             "extraneous file present in tar file")
 
 
+class TestSmartServerRepositoryStreamKnitData(tests.TestCaseWithTransport):
+
+    def test_fetch_revisions(self):
+        backing = self.get_transport()
+        request = smart.repository.SmartServerRepositoryStreamKnitDataForRevisions(backing)
+        tree = self.make_branch_and_memory_tree('.')
+        tree.lock_write()
+        tree.add('')
+        rev_id1_utf8 = u'\xc8'.encode('utf-8')
+        rev_id2_utf8 = u'\xc9'.encode('utf-8')
+        r1 = tree.commit('1st commit', rev_id=rev_id1_utf8)
+        r1 = tree.commit('2nd commit', rev_id=rev_id2_utf8)
+        tree.unlock()
+
+        response = request.execute(backing.local_abspath(''), rev_id2_utf8)
+        self.assertEqual(('ok',), response.args)
+        from cStringIO import StringIO
+        unpacker = pack.ContainerReader(StringIO(response.body))
+        names = []
+        for [name], read_bytes in unpacker.iter_records():
+            names.append(name)
+            bytes = read_bytes(None)
+            # The bytes should be a valid bencoded string.
+            bencode.bdecode(bytes)
+            # XXX: assert that the bencoded knit records have the right
+            # contents?
+        
+    def test_no_such_revision_error(self):
+        backing = self.get_transport()
+        request = smart.repository.SmartServerRepositoryStreamKnitDataForRevisions(backing)
+        repo = self.make_repository('.')
+        rev_id1_utf8 = u'\xc8'.encode('utf-8')
+        response = request.execute(backing.local_abspath(''), rev_id1_utf8)
+        self.assertEqual(
+            SmartServerResponse(('NoSuchRevision', rev_id1_utf8)),
+            response)
+
+
 class TestSmartServerIsReadonly(tests.TestCaseWithTransport):
 
     def test_is_readonly_no(self):

# Begin bundle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