debugcommands: add debugwireproto command
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).
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.
Differential Revision: https://phab.mercurial-scm.org/D2392
--- a/mercurial/debugcommands.py Tue Feb 27 15:47:44 2018 -0800
+++ b/mercurial/debugcommands.py Thu Mar 01 08:24:54 2018 -0800
@@ -17,6 +17,7 @@
import socket
import ssl
import string
+import subprocess
import sys
import tempfile
import time
@@ -65,6 +66,7 @@
setdiscovery,
simplemerge,
smartset,
+ sshpeer,
sslutil,
streamclone,
templater,
@@ -2529,3 +2531,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.
+ args = util.hgcmd() + [
+ '-R', repo.root,
+ 'debugserve', '--sshstdio',
+ ]
+ 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 = util.unescapestr(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()
--- a/tests/test-completion.t Tue Feb 27 15:47:44 2018 -0800
+++ b/tests/test-completion.t Thu Mar 01 08:24:54 2018 -0800
@@ -121,6 +121,7 @@
debugupgraderepo
debugwalk
debugwireargs
+ debugwireproto
Do not show the alias of a debug command if there are other candidates
(this should hide rawcommit)
@@ -302,6 +303,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
--- a/tests/test-help.t Tue Feb 27 15:47:44 2018 -0800
+++ b/tests/test-help.t Thu Mar 01 08:24:54 2018 -0800
@@ -983,6 +983,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)
--- a/tests/test-ssh-proto.t Tue Feb 27 15:47:44 2018 -0800
+++ b/tests/test-ssh-proto.t Thu Mar 01 08:24:54 2018 -0800
@@ -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,11 +52,19 @@
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
`hg debugserve --sshstdio` works
@@ -80,16 +107,33 @@
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
@@ -127,26 +171,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
@@ -167,18 +248,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 !)
@@ -199,22 +299,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 !)
@@ -239,62 +371,154 @@
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
@@ -302,176 +526,402 @@
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 !)
@@ -500,17 +950,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 !)
@@ -578,95 +1045,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