[MERGE] Return (and expect) '3' rather than '2' from the 'hello' verb (protocol v3 patch 4/7)

[Andrew Bennetts]

John Arbash Meinel wrote:
> John Arbash Meinel has voted tweak.
> Status is now: Conditionally approved
> Comment:
> +    def args_received(self, args):
> +        cmd = args[0]
> +        args = args[1:]
> +        try:
> +            command = self._commands.get(cmd)
> +        except LookupError:
> +            raise errors.SmartProtocolError("bad request %r" % (cmd,))
> +        self._command = command(self._backing_transport)
> +        self._run_handler_code(self._command.execute, args, {})
> +
>
> ^- Shouldn't this also raise UnknownSmartMethod?

Huh, yes.  Thanks!  I'll fix that.

> So... won't older clients refuse to connect to a server which returns  
> '3' for OK? It seems like all the logic in the server is still present  
> to be able to talk in V2 mode. Shouldn't there be a way for clients to  
> request this?

Sadly, yes.  This was the least well-cooked part of the patch set.

I've attached a merge directive (relative to the rest of the smart protocol v3
work) that fixes this.

It implements detection the server protocol version a better way: the first time
a request is made, it simply tries v3, then it tries v2, then it gives up.
After that, it remembers the version it detected.  'hello' is no longer used by
this client.

An alternative solution I considered and rejected was adding a new 'helloV3'
verb (maybe called 'SupportedVersions') that could return a list of supported
protocol versions, which would be more future proof than the existing 'hello'
verb.  This would have involved some moderately complicated code to fallback to
'hello' when 'helloV3' isn't there, plus adding yet another verb.  And we'd need
to be pretty careful about how we defined the verb to make sure it was *really*
future-proof, unlike our last effort.  And really we've wanted to stop needing
'hello' for a long time; it's just a wasted round-trip when the client's default
protocol version is understood by the server.  So even though I started writing
this solution, after chatting with Martin I decided it wasn't worth it.

Unfortunately, I also have removed the ability for this client to automatically
detect (and thus interoperate with) protocol 1 servers.  IIRC protocol 2 was
introduced around bzr 0.18, so I don't think this is a big burden.  We can
extend the existing detection logic to v1 (and there is code, with extensive
tests, to do so earlier in this branch), but it is fundamentally hard to do
well.  It's hard to distinguish "connection interrupted" and "server does not
speak v1" reliably, because v1 had no marker string, or any structure at all in
general except that there had to be a newline byte somewhere.  So code to detect
v1 while minimising the risk of confusing "connection reset, please check
connectivity etc" with "server is not a bzr server" was pretty hairy.  I'm open
to reviving this capability if people feel it is important.

I also discovered a bug in the v3 implementation: responses weren't being
prefixed with the protocol marker string!  The fix for that is in this patch
too, as I needed it fixed for this detection scheme to work nicely.

It also slightly changes how headers are set; now the _SmartClient is
responsible for setting the default headers on v3 requests, rather than the v3
guts, which I think is more appropriate.  Thanks to Martin for helping me
improve this aspect of the code.

The attached change *doesn't* yet change 'hello' back to returning '2' (or skip
calling medium.protocol_version() in RemoteBzrDirFormat.probe_transport); but
that is fairly trivial compared to this patch.  I will do that ASAP, but it was
important to get this new code up for review quickly.  Because the new client
doesn't use 'hello' implicitly anymore, the impact of reverting 'hello's result
back to '2' should be minimal.

The MockMedium class added to test_smart_transport is fairly complicated as far
as test infrastructure goes, but it also makes the test methods that use it much
more readable, robust (and easy to change if e.g. we do want to auto-detect v1)
than other alternatives, so I hope it isn't considered too heavy.  I've tried to
document it fairly extensively, and hopefully it'll be of use to other tests
too.

I'm aiming to get the v3 code landed in time for bzr 1.5 rc1.  I believe this
patch resolves the largest outstanding issue, so a review of this patch would be
an enormous help.

-Andrew.

-------------- next part --------------
# Bazaar merge directive format 2 (Bazaar 0.90)
# revision_id: andrew.bennetts at canonical.com-20080507144059-\
#   k37zunww6d4ujc10
# target_branch: http://bazaar-vcs.org/bzr/bzr.dev
# testament_sha1: 34834f36c3bd4241cd8e2c64bff9d68efd58c9f4
# timestamp: 2008-05-08 01:08:08 +1000
# source_branch: http://people.ubuntu.com/~andrew/bzr/protocol-v3-loom
# base_revision_id: andrew.bennetts at canonical.com-20080506010555-\
#   lika6fza402br9sm
# 
# Begin patch
=== modified file 'bzrlib/errors.py'
--- bzrlib/errors.py	2008-04-29 22:52:34 +0000
+++ bzrlib/errors.py	2008-05-07 10:33:00 +0000
@@ -1476,6 +1476,14 @@
         self.details = details
 
 
+class UnexpectedProtocolVersionMarker(TransportError):
+
+    _fmt = "Unexpected protocol version marker: %(marker)r"
+
+    def __init__(self, marker):
+        self.marker = marker
+
+
 class UnknownSmartMethod(InternalBzrError):
 
     _fmt = "The server does not recognise the '%(verb)s' request."

=== modified file 'bzrlib/smart/client.py'
--- bzrlib/smart/client.py	2008-04-23 22:43:14 +0000
+++ bzrlib/smart/client.py	2008-05-07 14:22:24 +0000
@@ -1,4 +1,4 @@
-# Copyright (C) 2006 Canonical Ltd
+# Copyright (C) 2006-2008 Canonical Ltd
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -16,13 +16,14 @@
 
 import urllib
 
+import bzrlib
 from bzrlib.smart import message, protocol
-from bzrlib import urlutils
+from bzrlib import urlutils, errors
 
 
 class _SmartClient(object):
 
-    def __init__(self, medium, base):
+    def __init__(self, medium, base, headers=None):
         """Constructor.
 
         :param medium: a SmartClientMedium
@@ -30,14 +31,58 @@
         """
         self._medium = medium
         self._base = base
-
-    def _build_client_protocol(self):
-        version = self._medium.protocol_version()
+        self._protocol_version = None
+        if headers is None:
+            self._headers = {'Software version': bzrlib.__version__}
+        else:
+            self._headers = dict(headers)
+
+    def _call(self, encoder, method, args, body=None, readv_body=None):
+        encoder.set_headers(self._headers)
+        if body is not None:
+            encoder.call_with_body_bytes((method, ) + args, body)
+        elif readv_body is not None:
+            encoder.call_with_body_readv_array((method, ) + args,
+                    readv_body)
+        else:
+            encoder.call(method, *args)
+
+    def _call_and_read_response(self, method, args, body=None, readv_body=None,
+            expect_response_body=True):
+        if self._protocol_version is not None:
+            encoder, response_handler = self._construct_protocol(
+                self._protocol_version)
+            self._call(encoder, method, args, body=body, readv_body=readv_body)
+            return (response_handler.read_response_tuple(
+                        expect_body=expect_response_body),
+                    response_handler)
+        else:
+            for protocol_version in [3, 2]:
+                encoder, response_handler = self._construct_protocol(
+                    protocol_version)
+                self._call(encoder, method, args, body=body,
+                           readv_body=readv_body)
+                try:
+                    response_tuple = response_handler.read_response_tuple(
+                        expect_body=expect_response_body)
+                except errors.UnexpectedProtocolVersionMarker, err:
+                    # TODO: We could recover from this without disconnecting if
+                    # we recognise the protocol version.
+                    self._medium.disconnect()
+                    continue
+                else:
+                    self._protocol_version = protocol_version
+                    return response_tuple, response_handler
+            raise errors.SmartProtocolError(
+                'Server is not a Bazaar server: ' + str(err))
+
+    def _construct_protocol(self, version):
         request = self._medium.get_request()
         if version == 3:
             request_encoder = protocol.ProtocolThreeRequester(request)
             response_handler = message.ConventionalResponseHandler()
-            response_proto = protocol.ProtocolThreeDecoder(response_handler)
+            response_proto = protocol.ProtocolThreeDecoder(
+                response_handler, expect_version_marker=True)
             response_handler.setProtoAndMediumRequest(response_proto, request)
         elif version == 2:
             request_encoder = protocol.SmartClientRequestProtocolTwo(request)
@@ -61,10 +106,8 @@
             result, smart_protocol = smart_client.call_expecting_body(...)
             body = smart_protocol.read_body_bytes()
         """
-        request_encoder, response_handler = self._build_client_protocol()
-        request_encoder.call(method, *args)
-        return (response_handler.read_response_tuple(expect_body=True),
-                response_handler)
+        return self._call_and_read_response(
+            method, args, expect_response_body=True)
 
     def call_with_body_bytes(self, method, args, body):
         """Call a method on the remote server with body bytes."""
@@ -75,9 +118,9 @@
                 raise TypeError('args must be byte strings, not %r' % (args,))
         if type(body) is not str:
             raise TypeError('body must be byte string, not %r' % (body,))
-        request_encoder, response_handler = self._build_client_protocol()
-        request_encoder.call_with_body_bytes((method, ) + args, body)
-        return response_handler.read_response_tuple()
+        response, response_handler = self._call_and_read_response(
+            method, args, body=body, expect_response_body=False)
+        return response
 
     def call_with_body_bytes_expecting_body(self, method, args, body):
         """Call a method on the remote server with body bytes."""
@@ -88,16 +131,14 @@
                 raise TypeError('args must be byte strings, not %r' % (args,))
         if type(body) is not str:
             raise TypeError('body must be byte string, not %r' % (body,))
-        request_encoder, response_handler = self._build_client_protocol()
-        request_encoder.call_with_body_bytes((method, ) + args, body)
-        return (response_handler.read_response_tuple(expect_body=True),
-                response_handler)
+        response, response_handler = self._call_and_read_response(
+            method, args, body=body, expect_response_body=True)
+        return (response, response_handler)
 
     def call_with_body_readv_array(self, args, body):
-        request_encoder, response_handler = self._build_client_protocol()
-        request_encoder.call_with_body_readv_array(args, body)
-        return (response_handler.read_response_tuple(expect_body=True),
-                response_handler)
+        response, response_handler = self._call_and_read_response(
+                args[0], args[1:], readv_body=body, expect_response_body=True)
+        return (response, response_handler)
 
     def remote_path_from_transport(self, transport):
         """Convert transport into a path suitable for using in a request.

=== modified file 'bzrlib/smart/protocol.py'
--- bzrlib/smart/protocol.py	2008-04-23 22:43:14 +0000
+++ bzrlib/smart/protocol.py	2008-05-07 14:06:29 +0000
@@ -89,6 +89,9 @@
         """
         raise NotImplementedError(self.call_with_body_readv_array)
 
+    def set_headers(self, headers):
+        raise NotImplementedError(self.set_headers)
+
 
 class SmartProtocolBase(object):
     """Methods common to client and server"""
@@ -523,6 +526,10 @@
         self._body_buffer = None
         self._request_start_time = None
         self._last_verb = None
+        self._headers = None
+
+    def set_headers(self, headers):
+        self._headers = dict(headers)
 
     def call(self, *args):
         if 'hpss' in debug.debug_flags:
@@ -731,7 +738,7 @@
         """
         version = self._request.read_line()
         if version != self.response_marker:
-            raise errors.SmartProtocolError('bad protocol marker %r' % version)
+            raise errors.UnexpectedProtocolVersionMarker(version)
         response_status = self._recv_line()
         result = SmartClientRequestProtocolOne._read_response_tuple(self)
         if response_status == 'success\n':
@@ -788,13 +795,19 @@
     response_marker = RESPONSE_VERSION_THREE
     request_marker = REQUEST_VERSION_THREE
 
-    def __init__(self, message_handler):
+    def __init__(self, message_handler, expect_version_marker=False):
         _StatefulDecoder.__init__(self)
         self.has_dispatched = False
         # Initial state
         self._in_buffer = ''
-        self._number_needed_bytes = 4
-        self.state_accept = self._state_accept_expecting_headers
+        if expect_version_marker:
+            self.state_accept = self._state_accept_expecting_protocol_version
+            # We're expecting at least the protocol version marker + some
+            # headers.
+            self._number_needed_bytes = len(MESSAGE_VERSION_THREE) + 4
+        else:
+            self.state_accept = self._state_accept_expecting_headers
+            self._number_needed_bytes = 4
         self.errored = False
 
         self.request_handler = self.message_handler = message_handler
@@ -843,6 +856,19 @@
         self._in_buffer = self._in_buffer[1:]
         return one_byte
 
+    def _state_accept_expecting_protocol_version(self, bytes):
+        self._in_buffer += bytes
+        needed_bytes = len(MESSAGE_VERSION_THREE) - len(self._in_buffer)
+        if needed_bytes > 0:
+            if not MESSAGE_VERSION_THREE.startswith(self._in_buffer):
+                # We have enough bytes to know the protocol version is wrong
+                raise errors.UnexpectedProtocolVersionMarker(self._in_buffer)
+            raise _NeedMoreBytes(len(MESSAGE_VERSION_THREE))
+        if not self._in_buffer.startswith(MESSAGE_VERSION_THREE):
+            raise errors.UnexpectedProtocolVersionMarker(self._in_buffer)
+        self._in_buffer = self._in_buffer[len(MESSAGE_VERSION_THREE):]
+        self.state_accept = self._state_accept_expecting_headers
+
     def _state_accept_expecting_headers(self, bytes):
         self._in_buffer += bytes
         decoded = self._extract_prefixed_bencoded_data()
@@ -934,9 +960,7 @@
         self._write_func(struct.pack('!L', len(bytes)))
         self._write_func(bytes)
 
-    def _write_headers(self, headers=None):
-        if headers is None:
-            headers = {'Software version': bzrlib.__version__}
+    def _write_headers(self, headers):
         self._write_prefixed_bencode(headers)
 
     def _write_structure(self, args):
@@ -969,6 +993,7 @@
     def __init__(self, write_func):
         _ProtocolThreeEncoder.__init__(self, write_func)
         self.response_sent = False
+        self._headers = {'Software version': bzrlib.__version__}
 
     def send_error(self, exception):
         assert not self.response_sent
@@ -978,7 +1003,8 @@
             self.send_response(failure)
             return
         self.response_sent = True
-        self._write_headers()
+        self._write_protocol_version()
+        self._write_headers(self._headers)
         self._write_error_status()
         self._write_structure(('error', str(exception)))
         self._write_end()
@@ -986,7 +1012,8 @@
     def send_response(self, response):
         assert not self.response_sent
         self.response_sent = True
-        self._write_headers()
+        self._write_protocol_version()
+        self._write_headers(self._headers)
         if response.is_successful():
             self._write_success_status()
         else:
@@ -1005,15 +1032,12 @@
     def __init__(self, medium_request):
         _ProtocolThreeEncoder.__init__(self, medium_request.accept_bytes)
         self._medium_request = medium_request
+        self._headers = {}
 
-    def call(self, *args, **kw):
-        # XXX: ideally, signature would be call(self, *args, headers=None), but
-        # python doesn't allow that.  So, we fake it.
-        headers = None
-        if 'headers' in kw:
-            headers = kw.pop('headers')
-        if kw != {}:
-            raise TypeError('Unexpected keyword arguments: %r' % (kw,))
+    def set_headers(self, headers):
+        self._headers = dict(headers)
+        
+    def call(self, *args):
         if 'hpss' in debug.debug_flags:
             mutter('hpss call:   %s', repr(args)[1:-1])
             base = getattr(self._medium_request._medium, 'base', None)
@@ -1021,12 +1045,12 @@
                 mutter('             (to %s)', base)
             self._request_start_time = time.time()
         self._write_protocol_version()
-        self._write_headers(headers)
+        self._write_headers(self._headers)
         self._write_structure(args)
         self._write_end()
         self._medium_request.finished_writing()
 
-    def call_with_body_bytes(self, args, body, headers=None):
+    def call_with_body_bytes(self, args, body):
         """Make a remote call of args with body bytes 'body'.
 
         After calling this, call read_response_tuple to find the result out.
@@ -1039,13 +1063,13 @@
             mutter('              %d bytes', len(body))
             self._request_start_time = time.time()
         self._write_protocol_version()
-        self._write_headers(headers)
+        self._write_headers(self._headers)
         self._write_structure(args)
         self._write_prefixed_body(body)
         self._write_end()
         self._medium_request.finished_writing()
 
-    def call_with_body_readv_array(self, args, body, headers=None):
+    def call_with_body_readv_array(self, args, body):
         """Make a remote call with a readv array.
 
         The body is encoded with one line per readv offset pair. The numbers in
@@ -1058,7 +1082,7 @@
                 mutter('                  (to %s)', path)
             self._request_start_time = time.time()
         self._write_protocol_version()
-        self._write_headers(headers)
+        self._write_headers(self._headers)
         self._write_structure(args)
         readv_bytes = self._serialise_offsets(body)
         if 'hpss' in debug.debug_flags:

=== modified file 'bzrlib/tests/test_smart_transport.py'
--- bzrlib/tests/test_smart_transport.py	2008-05-06 01:05:55 +0000
+++ bzrlib/tests/test_smart_transport.py	2008-05-07 14:40:59 +0000
@@ -1230,7 +1230,7 @@
     and the request dispatching.
 
     Note: these tests are rudimentary versions of the command object tests in
-    test_remote.py.
+    test_smart.py.
     """
         
     def test_hello(self):
@@ -1369,30 +1369,26 @@
         
     def test_use_connection_factory(self):
         # We want to be able to pass a client as a parameter to RemoteTransport.
-        input = StringIO('ok\x011\n' + 'ok\n3\nbardone\n')
+        input = StringIO('ok\n3\nbardone\n')
         output = StringIO()
         client_medium = medium.SmartSimplePipesClientMedium(input, output)
         transport = remote.RemoteTransport(
             'bzr://localhost/', medium=client_medium)
+        # Disable version detection.
+        transport._client._protocol_version = 1
 
         # We want to make sure the client is used when the first remote
         # method is called.  No data should have been sent, or read.
         self.assertEqual(0, input.tell())
         self.assertEqual('', output.getvalue())
 
-        # Explicitly probe for the server version now, so that it doesn't
-        # happen implicitly when we call our first remote method.
-        client_medium.protocol_version()
-        output.seek(0)
-        output.truncate()
-
         # Now call a method that should result in one request: as the
         # transport makes its own protocol instances, we check on the wire.
         # XXX: TODO: give the transport a protocol factory, which can make
         # an instrumented protocol for us.
         self.assertEqual('bar', transport.get_bytes('foo'))
         # only the needed data should have been sent/received.
-        self.assertEqual(5 + 13, input.tell())
+        self.assertEqual(13, input.tell())
         self.assertEqual('get\x01/foo\n', output.getvalue())
 
     def test__translate_error_readonly(self):
@@ -1430,6 +1426,7 @@
         """
         # This is very similar to
         # bzrlib.smart.client._SmartClient._build_client_protocol
+        # XXX: make this use _SmartClient!
         if input_bytes is None:
             input = StringIO()
         else:
@@ -1445,7 +1442,8 @@
             assert self.response_decoder is not None
             requester = self.request_encoder(request)
             response_handler = message.ConventionalResponseHandler()
-            response_protocol = self.response_decoder(response_handler)
+            response_protocol = self.response_decoder(
+                response_handler, expect_version_marker=True)
             response_handler.setProtoAndMediumRequest(
                 response_protocol, request)
             return requester, response_handler, output
@@ -2431,7 +2429,8 @@
         correct bytes for that invocation.
         """
         requester, output = self.make_client_encoder_and_output()
-        requester.call('one arg', headers={'header name': 'header value'})
+        requester.set_headers({'header name': 'header value'})
+        requester.call('one arg')
         self.assertEquals(
             'bzr message 3 (bzr 1.3)\n' # protocol version
             '\x00\x00\x00\x1fd11:header name12:header valuee' # headers
@@ -2439,15 +2438,6 @@
             'e', # end
             output.getvalue())
 
-    def test_call_default_headers(self):
-        """ProtocolThreeRequester.call by default sends a 'Software
-        version' header.
-        """
-        requester, output = self.make_client_encoder_and_output()
-        requester.call('foo')
-        # XXX: using assertContainsRe is a pretty poor way to assert this.
-        self.assertContainsRe(output.getvalue(), 'Software version')
-        
     def test_call_with_body_bytes_smoke_test(self):
         """A smoke test for ProtocolThreeRequester.call_with_body_bytes.
 
@@ -2455,9 +2445,8 @@
         call_with_body_bytes emits the correct bytes for that invocation.
         """
         requester, output = self.make_client_encoder_and_output()
-        requester.call_with_body_bytes(
-            ('one arg',), 'body bytes',
-            headers={'header name': 'header value'})
+        requester.set_headers({'header name': 'header value'})
+        requester.call_with_body_bytes(('one arg',), 'body bytes')
         self.assertEquals(
             'bzr message 3 (bzr 1.3)\n' # protocol version
             '\x00\x00\x00\x1fd11:header name12:header valuee' # headers
@@ -2527,6 +2516,235 @@
         self.assertCallDoesNotBreakMedium('method', ('args',), u'body')
 
 
+class MockMedium(object):
+    """A mock medium that can be used to test _SmartClient.
+    
+    It can be given a series of requests to expect (and responses it should
+    return for them).  It can also be told when the client is expected to
+    disconnect a medium.  Expectations must be satisfied in the order they are
+    given, or else an AssertionError will be raised.
+
+    Typical use looks like::
+
+        medium = MockMedium()
+        medium.expect_request(...)
+        medium.expect_request(...)
+        medium.expect_request(...)
+    """
+
+    def __init__(self):
+        self.base = 'dummy base'
+        self._mock_request = _MockMediumRequest(self)
+        self._expected_events = []
+        
+    def expect_request(self, request_bytes, response_bytes,
+                       allow_partial_read=False):
+        """Expect 'request_bytes' to be sent, and reply with 'response_bytes'.
+
+        No assumption is made about how many times accept_bytes should be
+        called to send the request.  Similarly, no assumption is made about how
+        many times read_bytes/read_line are called by protocol code to read a
+        response.  e.g.::
+        
+            request.accept_bytes('ab')
+            request.accept_bytes('cd')
+            request.finished_writing()
+
+        and::
+        
+            request.accept_bytes('abcd')
+            request.finished_writing()
+
+        Will both satisfy ``medium.expect_request('abcd', ...)``.  Thus tests
+        using this should not break due to irrelevant changes in protocol
+        implementations.
+
+        :param allow_partial_read: if True, no assertion is raised if a
+            response is not fully read.  Setting this is useful when the client
+            is expected to disconnect without needing to read the complete
+            response.  Default is False.
+        """
+        self._expected_events.append(('send request', request_bytes))
+        if allow_partial_read:
+            self._expected_events.append(
+                ('read response (partial)', response_bytes))
+        else:
+            self._expected_events.append(('read response', response_bytes))
+
+    def expect_disconnect(self):
+        """Expect the client to call ``medium.disconnect()``."""
+        self._expected_events.append('disconnect')
+
+    def _assertEvent(self, observed_event):
+        """Raise AssertionError unless observed_event matches the next expected
+        event.
+
+        :seealso: expect_request
+        :seealso: expect_disconnect
+        """
+        try:
+            expected_event = self._expected_events.pop(0)
+        except IndexError:
+            raise AssertionError(
+                'Mock medium observed event %r, but no more events expected'
+                % (observed_event,))
+        if expected_event[0] == 'read response (partial)':
+            if observed_event[0] != 'read response':
+                raise AssertionError(
+                    'Mock medium observed event %r, but expected event %r'
+                    % (observed_event, expected_event))
+        elif observed_event != expected_event:
+            raise AssertionError(
+                'Mock medium observed event %r, but expected event %r'
+                % (observed_event, expected_event))
+        if self._expected_events:
+            next_event = self._expected_events[0]
+            if next_event[0].startswith('read response'):
+                self._mock_request._response = next_event[1]
+
+    def get_request(self):
+        return self._mock_request
+
+    def disconnect(self):
+        if self._mock_request._read_bytes:
+            self._assertEvent(('read response', self._mock_request._read_bytes))
+            self._mock_request._read_bytes = ''
+        self._assertEvent('disconnect')
+
+
+class _MockMediumRequest(object):
+    """A mock ClientMediumRequest used by MockMedium."""
+
+    def __init__(self, mock_medium):
+        self._medium = mock_medium
+        self._written_bytes = ''
+        self._read_bytes = ''
+        self._response = None
+
+    def accept_bytes(self, bytes):
+        self._written_bytes += bytes
+
+    def finished_writing(self):
+        self._medium._assertEvent(('send request', self._written_bytes))
+        self._written_bytes = ''
+
+    def finished_reading(self):
+        self._medium._assertEvent(('read response', self._read_bytes))
+        self._read_bytes = ''
+
+    def read_bytes(self, size):
+        resp = self._response
+        bytes, resp = resp[:size], resp[size:]
+        self._response = resp
+        self._read_bytes += bytes
+        return bytes
+
+    def read_line(self):
+        resp = self._response
+        try:
+            line, resp = resp.split('\n', 1)
+            line += '\n'
+        except ValueError:
+            line, resp = resp, ''
+        self._response = resp
+        self._read_bytes += line
+        return line
+
+
+class Test_SmartClientVersionDetection(tests.TestCase):
+    """Tests for _SmartClient's automatic protocol version detection.
+
+    On the first remote call, _SmartClient will keep retrying the request with
+    different protocol versions until it finds one that works.
+    """
+
+    def test_version_three_server(self):
+        """With a protocol 3 server, only one request is needed."""
+        medium = MockMedium()
+        smart_client = client._SmartClient(medium, 'base', headers={})
+        message_start = protocol.MESSAGE_VERSION_THREE + '\x00\x00\x00\x02de'
+        medium.expect_request(
+            message_start +
+            's\x00\x00\x00\x1el11:method-name5:arg 15:arg 2ee',
+            message_start + 's\0\0\0\x13l14:response valueee')
+        result = smart_client.call('method-name', 'arg 1', 'arg 2')
+        # The call succeeded without raising any exceptions from the mock
+        # medium, and the smart_client returns the response from the server.
+        self.assertEqual(('response value',), result)
+        self.assertEqual([], medium._expected_events)
+
+    def test_version_two_server(self):
+        """If the server only speaks protocol 2, the client will first try
+        version 3, then fallback to protocol 2.
+
+        Further, _SmartClient caches the detection, so future requests will all
+        use protocol 2 immediately.
+        """
+        medium = MockMedium()
+        smart_client = client._SmartClient(medium, 'base', headers={})
+        # First the client should send a v3 request, but the server will reply
+        # with a v2 error.
+        medium.expect_request(
+            'bzr message 3 (bzr 1.3)\n\x00\x00\x00\x02de' +
+            's\x00\x00\x00\x1el11:method-name5:arg 15:arg 2ee',
+            'bzr response 2\nfailed\n\n')
+        # So then the client should disconnect to reset the connection, because
+        # the client needs to assume the server cannot read any further
+        # requests off the original connection.
+        medium.expect_disconnect()
+        # The client should then retry the original request in v2
+        medium.expect_request(
+            'bzr request 2\nmethod-name\x01arg 1\x01arg 2\n',
+            'bzr response 2\nsuccess\nresponse value\n')
+        result = smart_client.call('method-name', 'arg 1', 'arg 2')
+        # The smart_client object will return the result of the successful
+        # query.
+        self.assertEqual(('response value',), result)
+
+        # Now try another request, and this time the client will just use
+        # protocol 2.  (i.e. the autodetection won't be repeated)
+        medium.expect_request(
+            'bzr request 2\nanother-method\n',
+            'bzr response 2\nsuccess\nanother response\n')
+        result = smart_client.call('another-method')
+        self.assertEqual(('another response',), result)
+        self.assertEqual([], medium._expected_events)
+
+    def test_unknown_version(self):
+        """If the server does not use any known (or at least supported)
+        protocol version, a SmartProtocolError is raised.
+        """
+        medium = MockMedium()
+        smart_client = client._SmartClient(medium, 'base', headers={})
+        unknown_protocol_bytes = 'Unknown protocol!'
+        # The client will try v3 and v2 before eventually giving up.
+        medium.expect_request(
+            'bzr message 3 (bzr 1.3)\n\x00\x00\x00\x02de' +
+            's\x00\x00\x00\x1el11:method-name5:arg 15:arg 2ee',
+            unknown_protocol_bytes)
+        medium.expect_disconnect()
+        medium.expect_request(
+            'bzr request 2\nmethod-name\x01arg 1\x01arg 2\n',
+            unknown_protocol_bytes)
+        medium.expect_disconnect()
+        self.assertRaises(
+            errors.SmartProtocolError,
+            smart_client.call, 'method-name', 'arg 1', 'arg 2')
+        self.assertEqual([], medium._expected_events)
+        
+
+class Test_SmartClient(tests.TestCase):
+
+    def test_call_default_headers(self):
+        """ProtocolThreeRequester.call by default sends a 'Software
+        version' header.
+        """
+        smart_client = client._SmartClient(medium, 'base')
+        self.assertTrue('Software version' in smart_client._headers)
+        # XXX: need a test that smart_client._headers is passed to the request
+        # encoder.
+
+
 class LengthPrefixedBodyDecoder(tests.TestCase):
 
     # XXX: TODO: make accept_reading_trailer invoke translate_response or 

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