[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:
> This looks pretty good.  I still don't see a direct test for 
> self.item_keys_introduced_by, though.  Without that, there's no 
> justification for implementing it on RemoteRepository.

I've added a test for this.

> cdiff --check-style complains that there are 7 lines with trailing 
> whitespace, and 10 that exceed 79 columns.  Please clean up.

I've tidied up the long lines that I can; unfortunately the rather long class
name makes it hard to avoid in a couple of spots.  Let me know if you have
specific suggestions to fix these, but I'm not too bothered (even though I
recently switched to using two 79-column windows side-by-side in my normal vim
usage).

My editor highlights trailing whitespace, and I didn't see any.  I think your
--check-style might be picking up lines that are entirely whitespace, e.g.
between method definitions in a class, or other blank lines inside indented
code.  This seems harmless to me, and I don't see anything in HACKING.txtg or
PEP 8 against it.

> I know we plan to get the smart server running on bazaar-vcs.org, but we 
> shouldn't put this version on until that repository has been reconciled.

Agreed.  That shouldn't block us from merging this change though, IMO.

-Andrew.

-------------- next part --------------
# Bazaar merge directive format 2 (Bazaar 0.90)
# revision_id: andrew.bennetts at canonical.com-20070903163442-\
#   ytmz1xw42rdhuihi
# target_branch: http://bazaar-vcs.org/bzr/bzr.dev
# testament_sha1: 3eebbbcb545f28742c582c62ff858ebb607287c3
# timestamp: 2007-09-04 02:46:06 +1000
# source_branch: http://people.ubuntu.com/~andrew/bzr/repo-refactor
# base_revision_id: pqm at pqm.ubuntu.com-20070903130729-qdcrag0a7vcpzfgm
# 
# Begin patch
=== modified file 'bzrlib/errors.py'
--- bzrlib/errors.py	2007-09-03 08:39:17 +0000
+++ bzrlib/errors.py	2007-09-03 16:28:06 +0000
@@ -2355,6 +2355,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-09-03 16:02:07 +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-09-02 22:38:54 +0000
+++ bzrlib/knit.py	2007-09-03 09:03:17 +0000
@@ -749,6 +749,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: a
+                    # line-delta is no use unless we have its parent.
+                    # Fetching from a broken repository with this problem
+                    # shouldn't break the target repository.
+                    if not self._index.has_version(parents[0]):
+                        raise KnitCorrupt(
+                            self.filename,
+                            'line-delta from stream references '
+                            'missing parent %s' % parents[0])
                 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-09-03 16:24:16 +0000
@@ -128,6 +128,28 @@
             raise errors.NoSuchRevision(self, revision_id)
 
     @needs_read_lock
+    def get_data_stream(self, revision_ids):
+        """See Repository.get_data_stream."""
+        item_keys = self.item_keys_introduced_by(revision_ids)
+        for knit_kind, file_id, versions in item_keys:
+            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-09-03 16:02:07 +0000
@@ -306,6 +306,9 @@
                                '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-09-03 16:24:16 +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()
@@ -400,6 +461,43 @@
                           repository.iter_files_bytes(
                           [('file3-id', 'rev3', 'file1-notpresent')]))
 
+    def test_item_keys_introduced_by(self):
+        # Make a repo with one revision and one versioned file.
+        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
+
+        # Item keys will be in this order, for maximum convenience for
+        # generating data to insert into knit repository:
+        #   * files
+        #   * inventory
+        #   * signatures
+        #   * revisions
+        expected_item_keys = [
+            ('file', 'file1', ['rev_id']),
+            ('inventory', None, ['rev_id']),
+            ('signatures', None, []),
+            ('revisions', None, ['rev_id'])]
+        item_keys = list(repo.item_keys_introduced_by(['rev_id']))
+        item_keys = [
+            (kind, file_id, list(versions))
+            for (kind, file_id, versions) in item_keys]
+
+        if repo.supports_rich_root():
+            # Check for the root versioned file in the item_keys, then remove
+            # it from streamed_names so we can compare that with
+            # expected_record_names.
+            # Note that the file keys can be in any order, so this test is
+            # written to allow that.
+            inv = repo.get_inventory('rev_id')
+            root_item_key = ('file', inv.root.file_id, ['rev_id'])
+            self.assertTrue(root_item_key in item_keys)
+            item_keys.remove(root_item_key)
+
+        self.assertEqual(expected_item_keys, item_keys)
+
 
 class TestRepositoryLocking(TestCaseWithRepository):
 

=== 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-09-03 16:34:42 +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,47 @@
                                                         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')
+        is_compatible = repository.InterRemoteToOther.is_compatible
+        self.assertTrue(
+            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')
+        is_compatible = repository.InterRemoteToOther.is_compatible
+        self.assertFalse(
+            is_compatible(remote_repo, local_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')
+        is_compatible = repository.InterRemoteToOther.is_compatible
+        self.assertFalse(
+            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 +603,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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