Patchwork D2392: debugcommands: add debugwireproto command

login
register
mail settings
Submitter phabricator
Date Feb. 23, 2018, 12:51 a.m.
Message ID <differential-rev-PHID-DREV-kgsh4jmp6j7hll7w6w7o-req@phab.mercurial-scm.org>
Download mbox | patch
Permalink /patch/28263/
State Superseded
Headers show

Comments

phabricator - Feb. 23, 2018, 12:51 a.m.
indygreg created this revision.
Herald added a subscriber: mercurial-devel.
Herald added a reviewer: hg-reviewers.

REVISION SUMMARY
  We currently don't have a low-level mechanism for sending
  arbitrary wire protocol commands. Having a generic and robust
  mechanism for sending wire protocol commands, examining wire
  data, etc would make it vastly easier to test the wire protocol
  and debug server operation. This is a problem I've wanted a
  solution for numerous times, especially recently as I've been
  hacking on a new version of the wire protocol.
  
  This commit establishes a `hg debugwireproto` command for sending
  data to a peer.
  
  The command invents a mini language for specifying actions to take.
  This will enable a lot of flexibility for issuing commands and testing
  variations for how commands are sent.
  
  Right now, we only support low-level raw sends and receives. These
  are probably the least valuable commands to intended users of this
  command. But they are the most useful commands to implement to
  bootstrap the feature (I've chosen to reimplement test-ssh-proto.t
  using this command to prove its usefulness).
  
  We invent a mechanism to wrap a file object so we can observe
  activity on it. We have similar functionality in badserverext.py,
  but that's a test-only extension and is pretty specific to HTTP
  server. The new functionality needed to live in core because it
  needs to be accessible to `hg debugwireproto`.
  
  My eventual goal of `hg debugwireproto` is to allow calling wire
  protocol commands with a human-friendly interface. Essentially,
  people can type in a command name and arguments and
  `hg debugwireproto` will figure out how to send that on the wire.
  I'd love to eventually be able to save the server's raw response
  to a file. This would allow us to e.g. call "getbundle" wire
  protocol commands easily.
  
  test-ssh-proto.t has been updated to use the new command in lieu
  of piping directly to a server process. As part of the transition,
  test behavior improved. Before, we piped all request data to the
  server at once. Now, we have explicit control over the ordering of
  operations. e.g. we can send one command, receive its response,
  then send another command. This will allow us to more robustly
  test race conditions, buffering behavior, etc.
  
  There were some subtle changes in test behavior. For example,
  previous behavior would often send trailing newlines to the server.
  The new mechanism doesn't treat literal newlines specially and
  requires newlines be escaped in the payload.
  
  Because the new logging code is very low level, it is easy to
  introduce race conditions in tests. For example, the number of bytes
  returned by a read() may vary depending on load. This is why tests
  make heavy use of "readline" for consuming data: the result of
  that operation should be deterministic and not subject to race
  conditions. There are still some uses of "readavailable." However,
  those are only for reading from stderr. I was able to reproduce
  timing issues with my system under load when using "readavailable"
  globally. But if I "readline" to grab stdout, "readavailable"
  appears to work deterministically for stderr. I think this is
  because the server writes to stderr first. As long as the OS
  delivers writes to pipes in the same order they were made, this
  should work. If there are timing issues, we can introduce a
  mechanism to readline from stderr.

REPOSITORY
  rHG Mercurial

REVISION DETAIL
  https://phab.mercurial-scm.org/D2392

AFFECTED FILES
  mercurial/debugcommands.py
  mercurial/util.py
  tests/test-completion.t
  tests/test-help.t
  tests/test-ssh-proto.t

CHANGE DETAILS




To: indygreg, #hg-reviewers
Cc: mercurial-devel
phabricator - Feb. 23, 2018, 1:09 a.m.
indygreg added a subscriber: sid0.
indygreg added a comment.


  @sid0: I reckon we could find a way to take what I did in this commit and turn it into a wire protocol conformance tester. i.e. if we could refactor the test so it instantiates the server via alternate mechanisms, we could point the test at a separate server implementation as a means to tease out implementation differences. Just thought you'd like to know in case Mononoke would be interested in this.

REPOSITORY
  rHG Mercurial

REVISION DETAIL
  https://phab.mercurial-scm.org/D2392

To: indygreg, #hg-reviewers
Cc: sid0, mercurial-devel
phabricator - Feb. 24, 2018, 2:35 a.m.
indygreg planned changes to this revision.
indygreg added inline comments.

INLINE COMMENTS

> debugcommands.py:2630
> +        # separation. This prevents a whole class of potential bugs around
> +        # shared state from interfering with server operation.
> +

I'm having second thoughts about this.

The reason is that from a testing perspective (which is the primary driver behind this work), `read()` isn't very reliable because of timing issues. Depending on operating system settings, system performance, etc, operations like `read(-1)` can return a variable number of bytes because they return only what's available on the wire.

`write()`, however, is more reliable. When you `write()` to something in Python, Python makes as many system calls as necessary to ensure all bytes are delivered. So a `write()` at the Python level is mostly deterministic.

I think the concerns around process separation here aren't that significant. So I think I'm going to rework this (yet again) to spawn the SSH server in process and to only monitor I/O operations that are deterministic. This may mean only monitoring `write()` calls on pipes and *possibly* monitoring `readline()` and `read(N)`. But if we monitor `write()` on both peers since they are both in-process, then `read()` monitoring is redundant. That could be useful to debug behavior. But for tests demonstrating the wire protocol exchange, it's less useful.

REPOSITORY
  rHG Mercurial

REVISION DETAIL
  https://phab.mercurial-scm.org/D2392

To: indygreg, #hg-reviewers
Cc: sid0, mercurial-devel
phabricator - March 1, 2018, 11:04 a.m.
yuja requested changes to this revision.
yuja added a comment.
This revision now requires changes to proceed.


  This is OT, but I couldn't find a way to phabread this long series. `:D2462` (the topmost patch
  in yadda) appeared to lack many changes, and `:D2392` missed some dependency patches.
  And I gave up.

INLINE COMMENTS

> debugcommands.py:2661
> +        # shared state from interfering with server operation.
> +        args = [util.hgexecutable(), '-R', repo.root, 'debugserve',
> +                '--sshstdio']

Perhaps `util.hgcmd()` is more appropriate because we don't run the command
by the system shell.

> debugcommands.py:2707
> +            data = ''.join(l.lstrip() for l in lines)
> +            data = ast.literal_eval(b'''b"%s"''' % data)
> +            stdin.write(data)

util.unescapestr() can be used if we want to allow only string literals.

REPOSITORY
  rHG Mercurial

REVISION DETAIL
  https://phab.mercurial-scm.org/D2392

To: indygreg, #hg-reviewers, yuja
Cc: yuja, sid0, mercurial-devel
phabricator - March 1, 2018, 4:20 p.m.
indygreg added a comment.


  In https://phab.mercurial-scm.org/D2392#40790, @yuja wrote:
  
  > This is OT, but I couldn't find a way to phabread this long series. `:D2462` (the topmost patch
  >  in yadda) appeared to lack many changes, and `:D2392` missed some dependency patches.
  >  And I gave up.
  
  
  `hg phabsend` doesn't appear to update parent revisions when re-submitting???
  
  Anyway, I updated parent revisions manually through the web UI and I think things are all cleaned up.

REPOSITORY
  rHG Mercurial

REVISION DETAIL
  https://phab.mercurial-scm.org/D2392

To: indygreg, #hg-reviewers, yuja
Cc: yuja, sid0, mercurial-devel

Patch

diff --git a/tests/test-ssh-proto.t b/tests/test-ssh-proto.t
--- a/tests/test-ssh-proto.t
+++ b/tests/test-ssh-proto.t
@@ -12,10 +12,29 @@ 
   $ echo 0 > foo
   $ hg -q add foo
   $ hg commit -m initial
-  $ cd ..
+
+A no-op connection performs a handshake
+
+  $ hg debugwireproto --localssh << EOF
+  > EOF
+  creating ssh peer from handshake results
+
+Raw peers don't perform any activity
+
+  $ hg debugwireproto --localssh --peer raw << EOF
+  > EOF
+  using raw connection to peer
+  $ hg debugwireproto --localssh --peer ssh1 << EOF
+  > EOF
+  creating ssh peer for wire protocol version 1
+  $ hg debugwireproto --localssh --peer ssh2 << EOF
+  > EOF
+  creating ssh peer for wire protocol version 2
 
 Test a normal behaving server, for sanity
 
+  $ cd ..
+
   $ hg --debug debugpeer ssh://user@dummy/server
   running * "*/tests/dummyssh" 'user@dummy' 'hg -R server serve --stdio' (glob) (no-windows !)
   running * "*\tests/dummyssh" "user@dummy" "hg -R server serve --stdio" (glob) (windows !)
@@ -33,26 +52,51 @@ 
 
 Server should answer the "hello" command in isolation
 
-  $ hg -R server serve --stdio << EOF
-  > hello
+  $ hg -R server debugwireproto --localssh --peer raw << EOF
+  > raw
+  >     hello\n
+  > readline
+  > readline
   > EOF
-  384
-  capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
+  using raw connection to peer
+  i> write(6) -> None:
+  i>     hello\n
+  o> readline() -> 4:
+  o>     384\n
+  o> readline() -> 384:
+  o>     capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN\n
 
 >=0.9.1 clients send a "hello" + "between" for the null range as part of handshake.
 Server should reply with capabilities and should send "1\n\n" as a successful
 reply with empty response to the "between".
 
-  $ hg -R server serve --stdio << EOF
-  > hello
-  > between
-  > pairs 81
-  > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  $ hg -R server debugwireproto --localssh --peer raw << EOF
+  > raw
+  >     hello\n
+  > readline
+  > readline
+  > raw
+  >     between\n
+  >     pairs 81\n
+  >     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  > readline
+  > readline
   > EOF
-  384
-  capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
-  1
-  
+  using raw connection to peer
+  i> write(6) -> None:
+  i>     hello\n
+  o> readline() -> 4:
+  o>     384\n
+  o> readline() -> 384:
+  o>     capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN\n
+  i> write(98) -> None:
+  i>     between\n
+  i>     pairs 81\n
+  i>     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  o> readline() -> 2:
+  o>     1\n
+  o> readline() -> 1:
+  o>     \n
 
 SSH banner is not printed by default, ignored by clients
 
@@ -90,26 +134,63 @@ 
 
 And test the banner with the raw protocol
 
-  $ SSHSERVERMODE=banner hg -R server serve --stdio << EOF
-  > hello
-  > between
-  > pairs 81
-  > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  $ SSHSERVERMODE=banner hg -R server debugwireproto --localssh --peer raw << EOF
+  > raw
+  >     hello\n
+  > readline
+  > readline
+  > readline
+  > readline
+  > readline
+  > readline
+  > readline
+  > readline
+  > readline
+  > readline
+  > readline
+  > readline
+  > raw
+  >     between\n
+  >     pairs 81\n
+  >     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  > readline
+  > readline
   > EOF
-  banner: line 0
-  banner: line 1
-  banner: line 2
-  banner: line 3
-  banner: line 4
-  banner: line 5
-  banner: line 6
-  banner: line 7
-  banner: line 8
-  banner: line 9
-  384
-  capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
-  1
-  
+  using raw connection to peer
+  i> write(6) -> None:
+  i>     hello\n
+  o> readline() -> 15:
+  o>     banner: line 0\n
+  o> readline() -> 15:
+  o>     banner: line 1\n
+  o> readline() -> 15:
+  o>     banner: line 2\n
+  o> readline() -> 15:
+  o>     banner: line 3\n
+  o> readline() -> 15:
+  o>     banner: line 4\n
+  o> readline() -> 15:
+  o>     banner: line 5\n
+  o> readline() -> 15:
+  o>     banner: line 6\n
+  o> readline() -> 15:
+  o>     banner: line 7\n
+  o> readline() -> 15:
+  o>     banner: line 8\n
+  o> readline() -> 15:
+  o>     banner: line 9\n
+  o> readline() -> 4:
+  o>     384\n
+  o> readline() -> 384:
+  o>     capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN\n
+  i> write(98) -> None:
+  i>     between\n
+  i>     pairs 81\n
+  i>     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  o> readline() -> 2:
+  o>     1\n
+  o> readline() -> 1:
+  o>     \n
 
 Connecting to a <0.9.1 server that doesn't support the hello command.
 The client should refuse, as we dropped support for connecting to such
@@ -130,18 +211,37 @@ 
 
 Sending an unknown command to the server results in an empty response to that command
 
-  $ hg -R server serve --stdio << EOF
-  > pre-hello
-  > hello
-  > between
-  > pairs 81
-  > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  $ hg -R server debugwireproto --localssh --peer raw << EOF
+  > raw
+  >     pre-hello\n
+  > readline
+  > raw
+  >     hello\n
+  > readline
+  > raw
+  >     between\n
+  >     pairs 81\n
+  >     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  > readline
+  > readline
   > EOF
-  0
-  384
-  capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
-  1
-  
+  using raw connection to peer
+  i> write(10) -> None:
+  i>     pre-hello\n
+  o> readline() -> 2:
+  o>     0\n
+  i> write(6) -> None:
+  i>     hello\n
+  o> readline() -> 4:
+  o>     384\n
+  i> write(98) -> None:
+  i>     between\n
+  i>     pairs 81\n
+  i>     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  o> readline() -> 384:
+  o>     capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN\n
+  o> readline() -> 2:
+  o>     1\n
 
   $ hg --config sshpeer.mode=extra-handshake-commands --config sshpeer.handshake-mode=pre-no-args --debug debugpeer ssh://user@dummy/server
   running * "*/tests/dummyssh" 'user@dummy' 'hg -R server serve --stdio' (glob) (no-windows !)
@@ -162,22 +262,54 @@ 
 
 Send multiple unknown commands before hello
 
-  $ hg -R server serve --stdio << EOF
-  > unknown1
-  > unknown2
-  > unknown3
-  > hello
-  > between
-  > pairs 81
-  > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  $ hg -R server debugwireproto --localssh --peer raw << EOF
+  > raw
+  >     unknown1\n
+  > readline
+  > raw
+  >     unknown2\n
+  > readline
+  > raw
+  >     unknown3\n
+  > readline
+  > raw
+  >     hello\n
+  > readline
+  > readline
+  > raw
+  >     between\n
+  >     pairs 81\n
+  >     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  > readline
+  > readline
   > EOF
-  0
-  0
-  0
-  384
-  capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
-  1
-  
+  using raw connection to peer
+  i> write(9) -> None:
+  i>     unknown1\n
+  o> readline() -> 2:
+  o>     0\n
+  i> write(9) -> None:
+  i>     unknown2\n
+  o> readline() -> 2:
+  o>     0\n
+  i> write(9) -> None:
+  i>     unknown3\n
+  o> readline() -> 2:
+  o>     0\n
+  i> write(6) -> None:
+  i>     hello\n
+  o> readline() -> 4:
+  o>     384\n
+  o> readline() -> 384:
+  o>     capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN\n
+  i> write(98) -> None:
+  i>     between\n
+  i>     pairs 81\n
+  i>     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  o> readline() -> 2:
+  o>     1\n
+  o> readline() -> 1:
+  o>     \n
 
   $ hg --config sshpeer.mode=extra-handshake-commands --config sshpeer.handshake-mode=pre-multiple-no-args --debug debugpeer ssh://user@dummy/server
   running * "*/tests/dummyssh" 'user@dummy' 'hg -R server serve --stdio' (glob) (no-windows !)
@@ -202,239 +334,557 @@ 
 
 Send an unknown command before hello that has arguments
 
-  $ hg -R server serve --stdio << EOF
-  > with-args
-  > foo 13
-  > value for foo
-  > bar 13
-  > value for bar
-  > hello
-  > between
-  > pairs 81
-  > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  $ cd server
+
+  $ hg debugwireproto --localssh --peer raw << EOF
+  > raw
+  >     with-args\n
+  >     foo 13\n
+  >     value for foo\n
+  >     bar 13\n
+  >     value for bar\n
+  > readline
+  > readline
+  > readline
+  > readline
+  > readline
+  > raw
+  >     hello\n
+  > readline
+  > readline
+  > raw
+  >     between\n
+  >     pairs 81\n
+  >     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  > readline
+  > readline
   > EOF
-  0
-  0
-  0
-  0
-  0
-  384
-  capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
-  1
-  
+  using raw connection to peer
+  i> write(52) -> None:
+  i>     with-args\n
+  i>     foo 13\n
+  i>     value for foo\n
+  i>     bar 13\n
+  i>     value for bar\n
+  o> readline() -> 2:
+  o>     0\n
+  o> readline() -> 2:
+  o>     0\n
+  o> readline() -> 2:
+  o>     0\n
+  o> readline() -> 2:
+  o>     0\n
+  o> readline() -> 2:
+  o>     0\n
+  i> write(6) -> None:
+  i>     hello\n
+  o> readline() -> 4:
+  o>     384\n
+  o> readline() -> 384:
+  o>     capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN\n
+  i> write(98) -> None:
+  i>     between\n
+  i>     pairs 81\n
+  i>     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  o> readline() -> 2:
+  o>     1\n
+  o> readline() -> 1:
+  o>     \n
 
 Send an unknown command having an argument that looks numeric
 
-  $ hg -R server serve --stdio << EOF
-  > unknown
-  > foo 1
-  > 0
-  > hello
-  > between
-  > pairs 81
-  > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  $ hg debugwireproto --localssh --peer raw << EOF
+  > raw
+  >     unknown\n
+  >     foo 1\n
+  >     0\n
+  > readline
+  > readline
+  > readline
+  > raw
+  >     hello\n
+  > readline
+  > readline
+  > raw
+  >     between\n
+  >     pairs 81\n
+  >     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  > readline
+  > readline
   > EOF
-  0
-  0
-  0
-  384
-  capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
-  1
-  
+  using raw connection to peer
+  i> write(16) -> None:
+  i>     unknown\n
+  i>     foo 1\n
+  i>     0\n
+  o> readline() -> 2:
+  o>     0\n
+  o> readline() -> 2:
+  o>     0\n
+  o> readline() -> 2:
+  o>     0\n
+  i> write(6) -> None:
+  i>     hello\n
+  o> readline() -> 4:
+  o>     384\n
+  o> readline() -> 384:
+  o>     capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN\n
+  i> write(98) -> None:
+  i>     between\n
+  i>     pairs 81\n
+  i>     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  o> readline() -> 2:
+  o>     1\n
+  o> readline() -> 1:
+  o>     \n
 
-  $ hg -R server serve --stdio << EOF
-  > unknown
-  > foo 1
-  > 1
-  > hello
-  > between
-  > pairs 81
-  > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  $ hg debugwireproto --localssh --peer raw << EOF
+  > raw
+  >     unknown\n
+  >     foo 1\n
+  >     1\n
+  > readline
+  > readline
+  > readline
+  > raw
+  >     hello\n
+  > readline
+  > readline
+  > raw
+  >     between\n
+  >     pairs 81\n
+  >     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  > readline
+  > readline
   > EOF
-  0
-  0
-  0
-  384
-  capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
-  1
-  
+  using raw connection to peer
+  i> write(16) -> None:
+  i>     unknown\n
+  i>     foo 1\n
+  i>     1\n
+  o> readline() -> 2:
+  o>     0\n
+  o> readline() -> 2:
+  o>     0\n
+  o> readline() -> 2:
+  o>     0\n
+  i> write(6) -> None:
+  i>     hello\n
+  o> readline() -> 4:
+  o>     384\n
+  o> readline() -> 384:
+  o>     capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN\n
+  i> write(98) -> None:
+  i>     between\n
+  i>     pairs 81\n
+  i>     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  o> readline() -> 2:
+  o>     1\n
+  o> readline() -> 1:
+  o>     \n
 
 When sending a dict argument value, it is serialized to
 "<arg> <item count>" followed by "<key> <len>\n<value>" for each item
 in the dict.
 
 Dictionary value for unknown command
 
-  $ hg -R server serve --stdio << EOF
-  > unknown
-  > dict 3
-  > key1 3
-  > foo
-  > key2 3
-  > bar
-  > key3 3
-  > baz
-  > hello
+  $ hg debugwireproto --localssh --peer raw << EOF
+  > raw
+  >     unknown\n
+  >     dict 3\n
+  >     key1 3\n
+  >     foo\n
+  >     key2 3\n
+  >     bar\n
+  >     key3 3\n
+  >     baz\n
+  > readline
+  > readline
+  > readline
+  > readline
+  > readline
+  > readline
+  > readline
+  > readline
+  > raw
+  >     hello\n
+  > readline
+  > readline
   > EOF
-  0
-  0
-  0
-  0
-  0
-  0
-  0
-  0
-  384
-  capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
+  using raw connection to peer
+  i> write(48) -> None:
+  i>     unknown\n
+  i>     dict 3\n
+  i>     key1 3\n
+  i>     foo\n
+  i>     key2 3\n
+  i>     bar\n
+  i>     key3 3\n
+  i>     baz\n
+  o> readline() -> 2:
+  o>     0\n
+  o> readline() -> 2:
+  o>     0\n
+  o> readline() -> 2:
+  o>     0\n
+  o> readline() -> 2:
+  o>     0\n
+  o> readline() -> 2:
+  o>     0\n
+  o> readline() -> 2:
+  o>     0\n
+  o> readline() -> 2:
+  o>     0\n
+  o> readline() -> 2:
+  o>     0\n
+  i> write(6) -> None:
+  i>     hello\n
+  o> readline() -> 4:
+  o>     384\n
+  o> readline() -> 384:
+  o>     capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN\n
 
 Incomplete dictionary send
 
-  $ hg -R server serve --stdio << EOF
-  > unknown
-  > dict 3
-  > key1 3
-  > foo
+  $ hg debugwireproto --localssh --peer raw << EOF
+  > raw
+  >     unknown\n
+  >     dict 3\n
+  >     key1 3\n
+  >     foo\n
+  > readline
+  > readline
+  > readline
+  > readline
   > EOF
-  0
-  0
-  0
-  0
+  using raw connection to peer
+  i> write(26) -> None:
+  i>     unknown\n
+  i>     dict 3\n
+  i>     key1 3\n
+  i>     foo\n
+  o> readline() -> 2:
+  o>     0\n
+  o> readline() -> 2:
+  o>     0\n
+  o> readline() -> 2:
+  o>     0\n
+  o> readline() -> 2:
+  o>     0\n
 
 Incomplete value send
 
-  $ hg -R server serve --stdio << EOF
-  > unknown
-  > dict 3
-  > key1 3
-  > fo
+  $ hg debugwireproto --localssh --peer raw << EOF
+  > raw
+  >     unknown\n
+  >     dict 3\n
+  >     key1 3\n
+  >     fo
+  > readline
+  > readline
+  > readline
   > EOF
-  0
-  0
-  0
-  0
+  using raw connection to peer
+  i> write(24) -> None:
+  i>     unknown\n
+  i>     dict 3\n
+  i>     key1 3\n
+  i>     fo
+  o> readline() -> 2:
+  o>     0\n
+  o> readline() -> 2:
+  o>     0\n
+  o> readline() -> 2:
+  o>     0\n
 
 Send a command line with spaces
 
-  $ hg -R server serve --stdio << EOF
-  > unknown withspace
-  > hello
-  > between
-  > pairs 81
-  > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  $ hg debugwireproto --localssh --peer raw << EOF
+  > raw
+  >     unknown withspace\n
+  > readline
+  > raw
+  >     hello\n
+  > readline
+  > readline
+  > raw
+  >     between\n
+  >     pairs 81\n
+  >     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  > readline
+  > readline
   > EOF
-  0
-  384
-  capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
-  1
-  
+  using raw connection to peer
+  i> write(18) -> None:
+  i>     unknown withspace\n
+  o> readline() -> 2:
+  o>     0\n
+  i> write(6) -> None:
+  i>     hello\n
+  o> readline() -> 4:
+  o>     384\n
+  o> readline() -> 384:
+  o>     capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN\n
+  i> write(98) -> None:
+  i>     between\n
+  i>     pairs 81\n
+  i>     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  o> readline() -> 2:
+  o>     1\n
+  o> readline() -> 1:
+  o>     \n
 
-  $ hg -R server serve --stdio << EOF
-  > unknown with multiple spaces
-  > hello
-  > between
-  > pairs 81
-  > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  $ hg debugwireproto --localssh --peer raw << EOF
+  > raw
+  >     unknown with multiple spaces\n
+  > readline
+  > raw
+  >     hello\n
+  > readline
+  > readline
+  > raw
+  >     between\n
+  >     pairs 81\n
+  >     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  > readline
   > EOF
-  0
-  384
-  capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
-  1
-  
+  using raw connection to peer
+  i> write(29) -> None:
+  i>     unknown with multiple spaces\n
+  o> readline() -> 2:
+  o>     0\n
+  i> write(6) -> None:
+  i>     hello\n
+  o> readline() -> 4:
+  o>     384\n
+  o> readline() -> 384:
+  o>     capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN\n
+  i> write(98) -> None:
+  i>     between\n
+  i>     pairs 81\n
+  i>     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  o> readline() -> 2:
+  o>     1\n
 
-  $ hg -R server serve --stdio << EOF
-  > unknown with spaces
-  > key 10
-  > some value
-  > hello
-  > between
-  > pairs 81
-  > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  $ hg debugwireproto --localssh --peer raw << EOF
+  > raw
+  >     unknown with spaces\n
+  >     key 10\n
+  >     some value\n
+  > readline
+  > readline
+  > readline
+  > raw
+  >     hello\n
+  > readline
+  > readline
+  > raw
+  >     between\n
+  >     pairs 81\n
+  >     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  > readline
+  > readline
   > EOF
-  0
-  0
-  0
-  384
-  capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
-  1
-  
+  using raw connection to peer
+  i> write(38) -> None:
+  i>     unknown with spaces\n
+  i>     key 10\n
+  i>     some value\n
+  o> readline() -> 2:
+  o>     0\n
+  o> readline() -> 2:
+  o>     0\n
+  o> readline() -> 2:
+  o>     0\n
+  i> write(6) -> None:
+  i>     hello\n
+  o> readline() -> 4:
+  o>     384\n
+  o> readline() -> 384:
+  o>     capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN\n
+  i> write(98) -> None:
+  i>     between\n
+  i>     pairs 81\n
+  i>     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  o> readline() -> 2:
+  o>     1\n
+  o> readline() -> 1:
+  o>     \n
 
 Send an unknown command after the "between"
 
-  $ hg -R server serve --stdio << EOF
-  > hello
-  > between
-  > pairs 81
-  > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000unknown
+  $ hg debugwireproto --localssh --peer raw << EOF
+  > raw
+  >     hello\n
+  > readline
+  > readline
+  > raw
+  >     between\n
+  >     pairs 81\n
+  >     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000unknown
+  > readline
+  > readline
   > EOF
-  384
-  capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
-  1
-  
-  0
+  using raw connection to peer
+  i> write(6) -> None:
+  i>     hello\n
+  o> readline() -> 4:
+  o>     384\n
+  o> readline() -> 384:
+  o>     capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN\n
+  i> write(105) -> None:
+  i>     between\n
+  i>     pairs 81\n
+  i>     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000unknown
+  o> readline() -> 2:
+  o>     1\n
+  o> readline() -> 1:
+  o>     \n
 
 And one with arguments
 
-  $ hg -R server serve --stdio << EOF
-  > hello
-  > between
-  > pairs 81
-  > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000unknown
-  > foo 5
-  > value
-  > bar 3
-  > baz
+  $ hg debugwireproto --localssh --peer raw << EOF
+  > raw
+  >     hello\n
+  >     between\n
+  >     pairs 81\n
+  >     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  > readline
+  > readline
+  > readline
+  > readline
+  > raw
+  >     unknown\n
+  >     foo 5\n
+  >     \nvalue\n
+  >     bar 3\n
+  >     baz\n
+  > readline
+  > readline
+  > readline
   > EOF
-  384
-  capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
-  1
-  
-  0
-  0
-  0
-  0
-  0
+  using raw connection to peer
+  i> write(104) -> None:
+  i>     hello\n
+  i>     between\n
+  i>     pairs 81\n
+  i>     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  o> readline() -> 4:
+  o>     384\n
+  o> readline() -> 384:
+  o>     capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN\n
+  o> readline() -> 2:
+  o>     1\n
+  o> readline() -> 1:
+  o>     \n
+  i> write(31) -> None:
+  i>     unknown\n
+  i>     foo 5\n
+  i>     \n
+  i>     value\n
+  i>     bar 3\n
+  i>     baz\n
+  o> readline() -> 2:
+  o>     0\n
+  o> readline() -> 2:
+  o>     0\n
+  o> readline() -> 0: 
 
 Send a valid command before the handshake
 
-  $ hg -R server serve --stdio << EOF
-  > heads
-  > hello
-  > between
-  > pairs 81
-  > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  $ hg debugwireproto --localssh --peer raw << EOF
+  > raw
+  >     heads\n
+  > readline
+  > raw
+  >     hello\n
+  >     between\n
+  >     pairs 81\n
+  >     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  > readline
+  > readline
+  > readline
+  > readline
   > EOF
-  41
-  68986213bd4485ea51533535e3fc9e78007a711f
-  384
-  capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
-  1
-  
+  using raw connection to peer
+  i> write(6) -> None:
+  i>     heads\n
+  o> readline() -> 3:
+  o>     41\n
+  i> write(104) -> None:
+  i>     hello\n
+  i>     between\n
+  i>     pairs 81\n
+  i>     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  o> readline() -> 41:
+  o>     68986213bd4485ea51533535e3fc9e78007a711f\n
+  o> readline() -> 4:
+  o>     384\n
+  o> readline() -> 384:
+  o>     capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN\n
+  o> readline() -> 2:
+  o>     1\n
 
 And a variation that doesn't send the between command
 
-  $ hg -R server serve --stdio << EOF
-  > heads
-  > hello
+  $ hg debugwireproto --localssh --peer raw << EOF
+  > raw
+  >     heads\n
+  > readline
+  > raw
+  >     hello\n
+  > readline
+  > readline
   > EOF
-  41
-  68986213bd4485ea51533535e3fc9e78007a711f
-  384
-  capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
+  using raw connection to peer
+  i> write(6) -> None:
+  i>     heads\n
+  o> readline() -> 3:
+  o>     41\n
+  i> write(6) -> None:
+  i>     hello\n
+  o> readline() -> 41:
+  o>     68986213bd4485ea51533535e3fc9e78007a711f\n
+  o> readline() -> 4:
+  o>     384\n
 
 Send an upgrade request to a server that doesn't support that command
 
-  $ hg -R server serve --stdio << EOF
-  > upgrade 2e82ab3f-9ce3-4b4e-8f8c-6fd1c0e9e23a proto=irrelevant1%2Cirrelevant2
-  > hello
-  > between
-  > pairs 81
-  > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  $ hg debugwireproto --localssh --peer raw << EOF
+  > raw
+  >     upgrade 2e82ab3f-9ce3-4b4e-8f8c-6fd1c0e9e23a proto=irrelevant1%2Cirrelevant2\n
+  > readline
+  > raw
+  >     hello\n
+  >     between\n
+  >     pairs 81\n
+  >     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  > readline
+  > readline
+  > readline
+  > readline
   > EOF
-  0
-  384
-  capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
-  1
-  
+  using raw connection to peer
+  i> write(77) -> None:
+  i>     upgrade 2e82ab3f-9ce3-4b4e-8f8c-6fd1c0e9e23a proto=irrelevant1%2Cirrelevant2\n
+  o> readline() -> 2:
+  o>     0\n
+  i> write(104) -> None:
+  i>     hello\n
+  i>     between\n
+  i>     pairs 81\n
+  i>     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  o> readline() -> 4:
+  o>     384\n
+  o> readline() -> 384:
+  o>     capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN\n
+  o> readline() -> 2:
+  o>     1\n
+  o> readline() -> 1:
+  o>     \n
+
+  $ cd ..
 
   $ hg --config experimental.sshpeer.advertise-v2=true --debug debugpeer ssh://user@dummy/server
   running * "*/tests/dummyssh" 'user@dummy' 'hg -R server serve --stdio' (glob) (no-windows !)
@@ -463,17 +913,34 @@ 
 
 Send an upgrade request to a server that supports upgrade
 
-  >>> with open('payload', 'wb') as fh:
-  ...     fh.write(b'upgrade this-is-some-token proto=exp-ssh-v2-0001\n')
-  ...     fh.write(b'hello\n')
-  ...     fh.write(b'between\n')
-  ...     fh.write(b'pairs 81\n')
-  ...     fh.write(b'0000000000000000000000000000000000000000-0000000000000000000000000000000000000000')
+  $ cd server
 
-  $ hg -R server serve --stdio < payload
-  upgraded this-is-some-token exp-ssh-v2-0001
-  383
-  capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
+  $ hg debugwireproto --localssh --peer raw << EOF
+  > raw
+  >     upgrade this-is-some-token proto=exp-ssh-v2-0001\n
+  >     hello\n
+  >     between\n
+  >     pairs 81\n
+  >     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  > readline
+  > readline
+  > readline
+  > EOF
+  using raw connection to peer
+  i> write(153) -> None:
+  i>     upgrade this-is-some-token proto=exp-ssh-v2-0001\n
+  i>     hello\n
+  i>     between\n
+  i>     pairs 81\n
+  i>     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  o> readline() -> 44:
+  o>     upgraded this-is-some-token exp-ssh-v2-0001\n
+  o> readline() -> 4:
+  o>     383\n
+  o> readline() -> 384:
+  o>     capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN\n
+
+  $ cd ..
 
   $ hg --config experimental.sshpeer.advertise-v2=true --debug debugpeer ssh://user@dummy/server
   running * "*/tests/dummyssh" 'user@dummy' 'hg -R server serve --stdio' (glob) (no-windows !)
@@ -541,95 +1008,210 @@ 
 
 Command after upgrade to version 2 is processed
 
-  >>> with open('payload', 'wb') as fh:
-  ...     fh.write(b'upgrade this-is-some-token proto=exp-ssh-v2-0001\n')
-  ...     fh.write(b'hello\n')
-  ...     fh.write(b'between\n')
-  ...     fh.write(b'pairs 81\n')
-  ...     fh.write(b'0000000000000000000000000000000000000000-0000000000000000000000000000000000000000')
-  ...     fh.write(b'hello\n')
-  $ hg -R server serve --stdio < payload
-  upgraded this-is-some-token exp-ssh-v2-0001
-  383
-  capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
-  384
-  capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
+  $ cd server
+
+  $ hg debugwireproto --localssh --peer raw << EOF
+  > raw
+  >      upgrade this-is-some-token proto=exp-ssh-v2-0001\n
+  >      hello\n
+  >      between\n
+  >      pairs 81\n
+  >      0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  > readline
+  > readline
+  > readline
+  > raw
+  >      hello\n
+  > readline
+  > readline
+  > EOF
+  using raw connection to peer
+  i> write(153) -> None:
+  i>     upgrade this-is-some-token proto=exp-ssh-v2-0001\n
+  i>     hello\n
+  i>     between\n
+  i>     pairs 81\n
+  i>     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  o> readline() -> 44:
+  o>     upgraded this-is-some-token exp-ssh-v2-0001\n
+  o> readline() -> 4:
+  o>     383\n
+  o> readline() -> 384:
+  o>     capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN\n
+  i> write(6) -> None:
+  i>     hello\n
+  o> readline() -> 4:
+  o>     384\n
+  o> readline() -> 384:
+  o>     capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN\n
 
 Multiple upgrades is not allowed
 
-  >>> with open('payload', 'wb') as fh:
-  ...     fh.write(b'upgrade this-is-some-token proto=exp-ssh-v2-0001\n')
-  ...     fh.write(b'hello\n')
-  ...     fh.write(b'between\n')
-  ...     fh.write(b'pairs 81\n')
-  ...     fh.write(b'0000000000000000000000000000000000000000-0000000000000000000000000000000000000000')
-  ...     fh.write(b'upgrade another-token proto=irrelevant\n')
-  ...     fh.write(b'hello\n')
-  $ hg -R server serve --stdio < payload
-  upgraded this-is-some-token exp-ssh-v2-0001
-  383
-  capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
-  cannot upgrade protocols multiple times
-  -
-  
+  $ hg debugwireproto --localssh --peer raw << EOF
+  > raw
+  >     upgrade this-is-some-token proto=exp-ssh-v2-0001\n
+  >     hello\n
+  >     between\n
+  >     pairs 81\n
+  >     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  > readline
+  > readline
+  > readline
+  > raw
+  >     upgrade another-token proto=irrelevant\n
+  >     hello\n
+  > readline
+  > readavailable
+  > EOF
+  using raw connection to peer
+  i> write(153) -> None:
+  i>     upgrade this-is-some-token proto=exp-ssh-v2-0001\n
+  i>     hello\n
+  i>     between\n
+  i>     pairs 81\n
+  i>     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  o> readline() -> 44:
+  o>     upgraded this-is-some-token exp-ssh-v2-0001\n
+  o> readline() -> 4:
+  o>     383\n
+  o> readline() -> 384:
+  o>     capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN\n
+  i> write(45) -> None:
+  i>     upgrade another-token proto=irrelevant\n
+  i>     hello\n
+  o> readline() -> 1:
+  o>     \n
+  e> read(-1) -> 42:
+  e>     cannot upgrade protocols multiple times\n
+  e>     -\n
 
 Malformed upgrade request line (not exactly 3 space delimited tokens)
 
-  $ hg -R server serve --stdio << EOF
-  > upgrade
+  $ hg debugwireproto --localssh --peer raw << EOF
+  > raw
+  >     upgrade\n
+  > readline
   > EOF
-  0
+  using raw connection to peer
+  i> write(8) -> None:
+  i>     upgrade\n
+  o> readline() -> 2:
+  o>     0\n
 
-  $ hg -R server serve --stdio << EOF
-  > upgrade token
+  $ hg debugwireproto --localssh --peer raw << EOF
+  > raw
+  >     upgrade token\n
+  > readline
   > EOF
-  0
+  using raw connection to peer
+  i> write(14) -> None:
+  i>     upgrade token\n
+  o> readline() -> 2:
+  o>     0\n
 
-  $ hg -R server serve --stdio << EOF
-  > upgrade token foo=bar extra-token
+  $ hg debugwireproto --localssh --peer raw << EOF
+  > raw
+  >     upgrade token foo=bar extra-token\n
+  > readline
   > EOF
-  0
+  using raw connection to peer
+  i> write(34) -> None:
+  i>     upgrade token foo=bar extra-token\n
+  o> readline() -> 2:
+  o>     0\n
 
 Upgrade request to unsupported protocol is ignored
 
-  $ hg -R server serve --stdio << EOF
-  > upgrade this-is-some-token proto=unknown1,unknown2
-  > hello
-  > between
-  > pairs 81
-  > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  $ hg debugwireproto --localssh --peer raw << EOF
+  > raw
+  >     upgrade this-is-some-token proto=unknown1,unknown2\n
+  > readline
+  > raw
+  >     hello\n
+  > readline
+  > readline
+  > raw
+  >     between\n
+  >     pairs 81\n
+  >     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  > readline
+  > readline
   > EOF
-  0
-  384
-  capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
-  1
-  
+  using raw connection to peer
+  i> write(51) -> None:
+  i>     upgrade this-is-some-token proto=unknown1,unknown2\n
+  o> readline() -> 2:
+  o>     0\n
+  i> write(6) -> None:
+  i>     hello\n
+  o> readline() -> 4:
+  o>     384\n
+  o> readline() -> 384:
+  o>     capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN\n
+  i> write(98) -> None:
+  i>     between\n
+  i>     pairs 81\n
+  i>     0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  o> readline() -> 2:
+  o>     1\n
+  o> readline() -> 1:
+  o>     \n
 
 Upgrade request must be followed by hello + between
 
-  $ hg -R server serve --stdio << EOF
-  > upgrade token proto=exp-ssh-v2-0001
-  > invalid
+  $ hg debugwireproto --localssh --peer raw << EOF
+  > raw
+  >     upgrade token proto=exp-ssh-v2-0001\n
+  >     invalid\n
+  > readline
+  > readavailable
   > EOF
-  malformed handshake protocol: missing hello
-  -
-  
+  using raw connection to peer
+  i> write(44) -> None:
+  i>     upgrade token proto=exp-ssh-v2-0001\n
+  i>     invalid\n
+  o> readline() -> 1:
+  o>     \n
+  e> read(-1) -> 46:
+  e>     malformed handshake protocol: missing hello\n
+  e>     -\n
 
-  $ hg -R server serve --stdio << EOF
-  > upgrade token proto=exp-ssh-v2-0001
-  > hello
-  > invalid
+  $ hg debugwireproto --localssh --peer raw << EOF
+  > raw
+  >     upgrade token proto=exp-ssh-v2-0001\n
+  >     hello\n
+  >     invalid\n
+  > readline
+  > readavailable
   > EOF
-  malformed handshake protocol: missing between
-  -
-  
+  using raw connection to peer
+  i> write(50) -> None:
+  i>     upgrade token proto=exp-ssh-v2-0001\n
+  i>     hello\n
+  i>     invalid\n
+  o> readline() -> 1:
+  o>     \n
+  e> read(-1) -> 48:
+  e>     malformed handshake protocol: missing between\n
+  e>     -\n
 
-  $ hg -R server serve --stdio << EOF
-  > upgrade token proto=exp-ssh-v2-0001
-  > hello
-  > between
-  > invalid
+  $ hg debugwireproto --localssh --peer raw << EOF
+  > raw
+  >     upgrade token proto=exp-ssh-v2-0001\n
+  >     hello\n
+  >     between\n
+  >     invalid\n
+  > readline
+  > readavailable
   > EOF
-  malformed handshake protocol: missing pairs 81
-  -
-  
+  using raw connection to peer
+  i> write(58) -> None:
+  i>     upgrade token proto=exp-ssh-v2-0001\n
+  i>     hello\n
+  i>     between\n
+  i>     invalid\n
+  o> readline() -> 1:
+  o>     \n
+  e> read(-1) -> 49:
+  e>     malformed handshake protocol: missing pairs 81\n
+  e>     -\n
diff --git a/tests/test-help.t b/tests/test-help.t
--- a/tests/test-help.t
+++ b/tests/test-help.t
@@ -982,6 +982,8 @@ 
    debugwalk     show how files match on given patterns
    debugwireargs
                  (no help text available)
+   debugwireproto
+                 send wire protocol commands to a server
   
   (use 'hg help -v debug' to show built-in aliases and global options)
 
diff --git a/tests/test-completion.t b/tests/test-completion.t
--- a/tests/test-completion.t
+++ b/tests/test-completion.t
@@ -120,6 +120,7 @@ 
   debugupgraderepo
   debugwalk
   debugwireargs
+  debugwireproto
 
 Do not show the alias of a debug command if there are other candidates
 (this should hide rawcommit)
@@ -300,6 +301,7 @@ 
   debugupgraderepo: optimize, run
   debugwalk: include, exclude
   debugwireargs: three, four, five, ssh, remotecmd, insecure
+  debugwireproto: localssh, peer, ssh, remotecmd, insecure
   files: rev, print0, include, exclude, template, subrepos
   graft: rev, continue, edit, log, force, currentdate, currentuser, date, user, tool, dry-run
   grep: print0, all, text, follow, ignore-case, files-with-matches, line-number, rev, user, date, template, include, exclude
diff --git a/mercurial/util.py b/mercurial/util.py
--- a/mercurial/util.py
+++ b/mercurial/util.py
@@ -486,6 +486,212 @@ 
                          env=env)
     return p.stdin, p.stdout, p.stderr, p
 
+class fileobjectproxy(object):
+    """A proxy around file objects that tells a watcher when events occur.
+
+    This type is intended to only be used for testing purposes. Think hard
+    before using it in important code.
+    """
+    __slots__ = (
+        '_orig',
+        '_observer',
+    )
+
+    def __init__(self, fh, observer):
+        object.__setattr__(self, '_orig', fh)
+        object.__setattr__(self, '_observer', observer)
+
+    def __getattribute__(self, name):
+        ours = {
+            # IOBase
+            r'close',
+            # closed if a property
+            r'fileno',
+            r'flush',
+            r'isatty',
+            r'readable',
+            r'readline',
+            r'readlines',
+            r'seek',
+            r'seekable',
+            r'tell',
+            r'truncate',
+            r'writable',
+            r'writelines',
+            # RawIOBase
+            r'read',
+            r'readall',
+            r'readinto',
+            r'write',
+            # BufferedIOBase
+            # raw is a property
+            r'detach',
+            # read defined above
+            r'read1',
+            # readinto defined above
+            # write defined above
+        }
+
+        # We only observe some methods.
+        if name in ours:
+            return object.__getattribute__(self, name)
+
+        return getattr(object.__getattribute__(self, r'_orig'), name)
+
+    def __delattr__(self, name):
+        return delattr(object.__getattribute__(self, r'_orig'), name)
+
+    def __setattr__(self, name, value):
+        return setattr(object.__getattribute__(self, r'_orig'), name, value)
+
+    def __iter__(self):
+        return object.__getattribute__(self, r'_orig').__iter__()
+
+    def _observedcall(self, name, *args, **kwargs):
+        # Call the original object.
+        orig = object.__getattribute__(self, r'_orig')
+        res = getattr(orig, name)(*args, **kwargs)
+
+        # Call a method on the observer of the same name with arguments
+        # so it can react, log, etc.
+        observer = object.__getattribute__(self, r'_observer')
+        fn = getattr(observer, name, None)
+        if fn:
+            fn(res, *args, **kwargs)
+
+        return res
+
+    def close(self, *args, **kwargs):
+        return object.__getattribute__(self, r'_observedcall')(
+            r'close', *args, **kwargs)
+
+    def fileno(self, *args, **kwargs):
+        return object.__getattribute__(self, r'_observedcall')(
+            r'fileno', *args, **kwargs)
+
+    def flush(self, *args, **kwargs):
+        return object.__getattribute__(self, r'_observedcall')(
+            r'flush', *args, **kwargs)
+
+    def isatty(self, *args, **kwargs):
+        return object.__getattribute__(self, r'_observedcall')(
+            r'isatty', *args, **kwargs)
+
+    def readable(self, *args, **kwargs):
+        return object.__getattribute__(self, r'_observedcall')(
+            r'readable', *args, **kwargs)
+
+    def readline(self, *args, **kwargs):
+        return object.__getattribute__(self, r'_observedcall')(
+            r'readline', *args, **kwargs)
+
+    def readlines(self, *args, **kwargs):
+        return object.__getattribute__(self, r'_observedcall')(
+            r'readlines', *args, **kwargs)
+
+    def seek(self, *args, **kwargs):
+        return object.__getattribute__(self, r'_observedcall')(
+            r'seek', *args, **kwargs)
+
+    def seekable(self, *args, **kwargs):
+        return object.__getattribute__(self, r'_observedcall')(
+            r'seekable', *args, **kwargs)
+
+    def tell(self, *args, **kwargs):
+        return object.__getattribute__(self, r'_observedcall')(
+            r'tell', *args, **kwargs)
+
+    def truncate(self, *args, **kwargs):
+        return object.__getattribute__(self, r'_observedcall')(
+            r'truncate', *args, **kwargs)
+
+    def writable(self, *args, **kwargs):
+        return object.__getattribute__(self, r'_observedcall')(
+            r'writable', *args, **kwargs)
+
+    def writelines(self, *args, **kwargs):
+        return object.__getattribute__(self, r'_observedcall')(
+            r'writelines', *args, **kwargs)
+
+    def read(self, *args, **kwargs):
+        return object.__getattribute__(self, r'_observedcall')(
+            r'read', *args, **kwargs)
+
+    def readall(self, *args, **kwargs):
+        return object.__getattribute__(self, r'_observedcall')(
+            r'readall', *args, **kwargs)
+
+    def readinto(self, *args, **kwargs):
+        return object.__getattribute__(self, r'_observedcall')(
+            r'readinto', *args, **kwargs)
+
+    def write(self, *args, **kwargs):
+        return object.__getattribute__(self, r'_observedcall')(
+            r'write', *args, **kwargs)
+
+    def detach(self, *args, **kwargs):
+        return object.__getattribute__(self, r'_observedcall')(
+            r'detach', *args, **kwargs)
+
+    def read1(self, *args, **kwargs):
+        return object.__getattribute__(self, r'_observedcall')(
+            r'read1', *args, **kwargs)
+
+DATA_ESCAPE_MAP = {pycompat.bytechr(i): br'\x%02x' % i for i in range(256)}
+DATA_ESCAPE_MAP.update({
+    b'\\': b'\\\\',
+    b'\r': br'\r',
+    b'\n': br'\n',
+})
+DATA_ESCAPE_RE = remod.compile(br'[\x00-\x08\x0a-\x1f\\\x7f-\xff]')
+
+def escapedata(s):
+    return DATA_ESCAPE_RE.sub(lambda m: DATA_ESCAPE_MAP[m.group(0)], s)
+
+class fileobjectobserver(object):
+    """Logs file object activity."""
+    def __init__(self, fh, name, logdata=False):
+        self.fh = fh
+        self.name = name
+        self.logdata = logdata
+
+    def _writedata(self, data):
+        if not self.logdata:
+            self.fh.write('\n')
+            return
+
+        # Simple case writes all data on a single line.
+        if b'\n' not in data:
+            self.fh.write(': %s\n' % escapedata(data))
+            return
+
+        # Data with newlines is written to multiple lines.
+        self.fh.write(':\n')
+        lines = data.splitlines(True)
+        for line in lines:
+            self.fh.write('%s>     %s\n' % (self.name, escapedata(line)))
+
+    def read(self, res, size=-1):
+        self.fh.write('%s> read(%d) -> %d' % (self.name, size, len(res)))
+        self._writedata(res)
+
+    def readline(self, res, limit=-1):
+        self.fh.write('%s> readline() -> %d' % (self.name, len(res)))
+        self._writedata(res)
+
+    def write(self, res, data):
+        self.fh.write('%s> write(%d) -> %r' % (self.name, len(data), res))
+        self._writedata(data)
+
+    def flush(self, res):
+        self.fh.write('%s> flush() -> %r\n' % (self.name, res))
+
+def makeloggingfileobject(logh, fh, name, logdata=False):
+    """Turn a file object into a logging file object."""
+
+    observer = fileobjectobserver(logh, name, logdata=logdata)
+    return fileobjectproxy(fh, observer)
+
 def version():
     """Return version information if available."""
     try:
diff --git a/mercurial/debugcommands.py b/mercurial/debugcommands.py
--- a/mercurial/debugcommands.py
+++ b/mercurial/debugcommands.py
@@ -7,6 +7,7 @@ 
 
 from __future__ import absolute_import
 
+import ast
 import codecs
 import collections
 import difflib
@@ -17,6 +18,7 @@ 
 import socket
 import ssl
 import string
+import subprocess
 import sys
 import tempfile
 import time
@@ -65,6 +67,7 @@ 
     setdiscovery,
     simplemerge,
     smartset,
+    sshpeer,
     sslutil,
     streamclone,
     templater,
@@ -2498,3 +2501,204 @@ 
     ui.write("%s\n" % res1)
     if res1 != res2:
         ui.warn("%s\n" % res2)
+
+def _parsewirelangblocks(fh):
+    activeaction = None
+    blocklines = []
+
+    for line in fh:
+        line = line.rstrip()
+        if not line:
+            continue
+
+        if line.startswith(b'#'):
+            continue
+
+        if not line.startswith(' '):
+            # New block. Flush previous one.
+            if activeaction:
+                yield activeaction, blocklines
+
+            activeaction = line
+            blocklines = []
+            continue
+
+        # Else we start with an indent.
+
+        if not activeaction:
+            raise error.Abort(_('indented line outside of block'))
+
+        blocklines.append(line)
+
+    # Flush last block.
+    if activeaction:
+        yield activeaction, blocklines
+
+@command('debugwireproto',
+    [
+        ('', 'localssh', False, _('start an SSH server for this repo')),
+        ('', 'peer', '', _('construct a specific version of the peer')),
+    ] + cmdutil.remoteopts,
+    _('[REPO]'),
+    optionalrepo=True)
+def debugwireproto(ui, repo, **opts):
+    """send wire protocol commands to a server
+
+    This command can be used to issue wire protocol commands to remote
+    peers and to debug the raw data being exchanged.
+
+    ``--localssh`` will start an SSH server against the current repository
+    and connect to that. By default, the connection will perform a handshake
+    and establish an appropriate peer instance.
+
+    ``--peer`` can be used to bypass the handshake protocol and construct a
+    peer instance using the specified class type. Valid values are ``raw``,
+    ``ssh1``, and ``ssh2``. ``raw`` instances only allow sending raw data
+    payloads and don't support higher-level command actions.
+
+    Commands are issued via a mini language which is specified via stdin.
+    The language consists of individual actions to perform. An action is
+    defined by a block. A block is defined as a line with no leading
+    space followed by 0 or more lines with leading space. Blocks are
+    effectively a high-level command with additional metadata.
+
+    Lines beginning with ``#`` are ignored.
+
+    The following sections denote available actions.
+
+    raw
+    ---
+
+    Send raw data to the server.
+
+    The block payload contains the raw data to send as one atomic send
+    operation. The data may not actually be delivered in a single system
+    call: it depends on the abilities of the transport being used.
+
+    Each line in the block is de-indented and concatenated. Then, that
+    value is evaluated as a Python b'' literal. This allows the use of
+    backslash escaping, etc.
+
+    raw+
+    ----
+
+    Behaves like ``raw`` except flushes output afterwards.
+
+    close
+    -----
+
+    Close the connection to the server.
+
+    flush
+    -----
+
+    Flush data written to the server.
+
+    readavailable
+    -------------
+
+    Read all available data from the server.
+
+    If the connection to the server encompasses multiple pipes, we poll both
+    pipes and read available data.
+
+    readline
+    --------
+
+    Read a line of output from the server. If there are multiple output
+    pipes, reads only the main pipe.
+    """
+    opts = pycompat.byteskwargs(opts)
+
+    if opts['localssh'] and not repo:
+        raise error.Abort(_('--localssh requires a repository'))
+
+    if opts['peer'] and opts['peer'] not in ('raw', 'ssh1', 'ssh2'):
+        raise error.Abort(_('invalid value for --peer'),
+                          hint=_('valid values are "raw", "ssh1", and "ssh2"'))
+
+    if ui.interactive():
+        ui.write(_('(waiting for commands on stdin)\n'))
+
+    blocks = list(_parsewirelangblocks(ui.fin))
+
+    proc = None
+
+    if opts['localssh']:
+        # We start the SSH server in its own process so there is process
+        # separation. This prevents a whole class of potential bugs around
+        # shared state from interfering with server operation.
+
+        # We have to use -R because the argument pattern for
+        # `serve --stdio` is limited for security reasons.
+        args = [util.hgexecutable(), '-R', repo.root, 'serve', '--stdio']
+        proc = subprocess.Popen(args, stdin=subprocess.PIPE,
+                                stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                                bufsize=0)
+
+        stdin = proc.stdin
+        stdout = proc.stdout
+        stderr = proc.stderr
+
+        # We turn the pipes into observers so we can log I/O.
+        if ui.verbose or opts['peer'] == 'raw':
+            stdin = util.makeloggingfileobject(ui, proc.stdin, b'i',
+                                               logdata=True)
+            stdout = util.makeloggingfileobject(ui, proc.stdout, b'o',
+                                                logdata=True)
+            stderr = util.makeloggingfileobject(ui, proc.stderr, b'e',
+                                                logdata=True)
+
+        # --localssh also implies the peer connection settings.
+
+        url = 'ssh://localserver'
+
+        if opts['peer'] == 'ssh1':
+            ui.write(_('creating ssh peer for wire protocol version 1\n'))
+            peer = sshpeer.sshv1peer(ui, url, proc, stdin, stdout, stderr,
+                                     None)
+        elif opts['peer'] == 'ssh2':
+            ui.write(_('creating ssh peer for wire protocol version 2\n'))
+            peer = sshpeer.sshv2peer(ui, url, proc, stdin, stdout, stderr,
+                                     None)
+        elif opts['peer'] == 'raw':
+            ui.write(_('using raw connection to peer\n'))
+            peer = None
+        else:
+            ui.write(_('creating ssh peer from handshake results\n'))
+            peer = sshpeer.makepeer(ui, url, proc, stdin, stdout, stderr)
+
+    else:
+        raise error.Abort(_('only --localssh is currently supported'))
+
+    # Now perform actions based on the parsed wire language instructions.
+    for action, lines in blocks:
+        if action in ('raw', 'raw+'):
+            # Concatenate the data together.
+            data = ''.join(l.lstrip() for l in lines)
+            data = ast.literal_eval(b'''b"%s"''' % data)
+            stdin.write(data)
+
+            if action == 'raw+':
+                stdin.flush()
+        elif action == 'flush':
+            stdin.flush()
+        elif action == 'close':
+            peer.close()
+        elif action == 'readavailable':
+            fds = util.poll([stdout.fileno(), stderr.fileno()])
+
+            if stdout.fileno() in fds:
+                util.readpipe(stdout)
+            if stderr.fileno() in fds:
+                util.readpipe(stderr)
+        elif action == 'readline':
+            stdout.readline()
+        else:
+            raise error.Abort(_('unknown action: %s') % action)
+
+    if peer:
+        peer.close()
+
+    if proc:
+        proc.kill()