This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2392

debugcommands: add debugwireproto command
ClosedPublic

Authored by indygreg on Feb 22 2018, 7:50 PM.

Details

Reviewers
yuja
durin42
Group Reviewers
hg-reviewers
Commits
rHG72e487851a53: debugcommands: add debugwireproto command
rHG36f21b975efb: debugcommands: add debugwireproto command
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).

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.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

indygreg created this revision.Feb 22 2018, 7:50 PM
indygreg added a subscriber: sid0.Feb 22 2018, 8:09 PM

@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.

indygreg planned changes to this revision.Feb 23 2018, 9:34 PM
indygreg added inline comments.
mercurial/debugcommands.py
2660

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.

indygreg edited the summary of this revision. (Show Details)Feb 26 2018, 4:16 PM
indygreg updated this revision to Diff 6139.
yuja requested changes to this revision.Mar 1 2018, 6:04 AM
yuja added a subscriber: yuja.

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.

mercurial/debugcommands.py
2661

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

2707

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

This revision now requires changes to proceed.Mar 1 2018, 6:04 AM
indygreg added a comment.Mar 1 2018, 11:20 AM
In 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.

indygreg updated this revision to Diff 6250.Mar 1 2018, 11:30 AM
durin42 accepted this revision.Mar 1 2018, 4:35 PM
Closed by commit rHG36f21b975efb: debugcommands: add debugwireproto command (authored by indygreg). · Explain WhyMar 1 2018, 4:55 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/debugcommands.py (203 lines)
Mtests/test-completion.t (2 lines)
Mtests/test-help.t (2 lines)
Mtests/test-ssh-proto.t (1222 lines)

Diff 6283

mercurial/debugcommands.py

import difflib import difflib
import errno import errno
import operator import operator
import os import os
import random import random
import socket import socket
import ssl import ssl
import string import string
import subprocess
import sys import sys
import tempfile import tempfile
import time import time
from .i18n import _ from .i18n import _
from .node import ( from .node import (
bin, bin,
hex, hex,
repair, repair,
revlog, revlog,
revset, revset,
revsetlang, revsetlang,
scmutil, scmutil,
setdiscovery, setdiscovery,
simplemerge, simplemerge,
smartset, smartset,
sshpeer,
sslutil, sslutil,
streamclone, streamclone,
templater, templater,
treediscovery, treediscovery,
upgrade, upgrade,
url as urlmod, url as urlmod,
util, util,
vfs as vfsmod, vfs as vfsmod,
args[k] = v args[k] = v
args = pycompat.strkwargs(args) args = pycompat.strkwargs(args)
# run twice to check that we don't mess up the stream for the next command # run twice to check that we don't mess up the stream for the next command
res1 = repo.debugwireargs(*vals, **args) res1 = repo.debugwireargs(*vals, **args)
res2 = repo.debugwireargs(*vals, **args) res2 = repo.debugwireargs(*vals, **args)
ui.write("%s\n" % res1) ui.write("%s\n" % res1)
if res1 != res2: if res1 != res2:
ui.warn("%s\n" % 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.
indygregAuthorUnsubmitted
Not Done

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.

indygreg: I'm having second thoughts about this. The reason is that from a testing perspective (which is…
args = util.hgcmd() + [
yujaUnsubmitted
Not Done

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

yuja: Perhaps `util.hgcmd()` is more appropriate because we don't run the command by the system shell.
'-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.
yujaUnsubmitted
Not Done

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

yuja: util.unescapestr() can be used if we want to allow only string literals.
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()

tests/test-completion.t

debugssl debugssl
debugsub debugsub
debugsuccessorssets debugsuccessorssets
debugtemplate debugtemplate
debugupdatecaches debugupdatecaches
debugupgraderepo debugupgraderepo
debugwalk debugwalk
debugwireargs debugwireargs
debugwireproto
Do not show the alias of a debug command if there are other candidates Do not show the alias of a debug command if there are other candidates
(this should hide rawcommit) (this should hide rawcommit)
$ hg debugcomplete r $ hg debugcomplete r
recover recover
remove remove
rename rename
resolve resolve
debugssl: debugssl:
debugsub: rev debugsub: rev
debugsuccessorssets: closest debugsuccessorssets: closest
debugtemplate: rev, define debugtemplate: rev, define
debugupdatecaches: debugupdatecaches:
debugupgraderepo: optimize, run debugupgraderepo: optimize, run
debugwalk: include, exclude debugwalk: include, exclude
debugwireargs: three, four, five, ssh, remotecmd, insecure debugwireargs: three, four, five, ssh, remotecmd, insecure
debugwireproto: localssh, peer, ssh, remotecmd, insecure
files: rev, print0, include, exclude, template, subrepos files: rev, print0, include, exclude, template, subrepos
graft: rev, continue, edit, log, force, currentdate, currentuser, date, user, tool, dry-run 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 grep: print0, all, text, follow, ignore-case, files-with-matches, line-number, rev, user, date, template, include, exclude
heads: rev, topo, active, closed, style, template heads: rev, topo, active, closed, style, template
help: extension, command, keyword, system help: extension, command, keyword, system
identify: rev, num, id, branch, tags, bookmarks, ssh, remotecmd, insecure, template identify: rev, num, id, branch, tags, bookmarks, ssh, remotecmd, insecure, template
import: strip, base, edit, force, no-commit, bypass, partial, exact, prefix, import-branch, message, logfile, date, user, similarity import: strip, base, edit, force, no-commit, bypass, partial, exact, prefix, import-branch, message, logfile, date, user, similarity
incoming: force, newest-first, bundle, rev, bookmarks, branch, patch, git, limit, no-merges, stat, graph, style, template, ssh, remotecmd, insecure, subrepos incoming: force, newest-first, bundle, rev, bookmarks, branch, patch, git, limit, no-merges, stat, graph, style, template, ssh, remotecmd, insecure, subrepos

tests/test-help.t

parse and apply a template parse and apply a template
debugupdatecaches debugupdatecaches
warm all known caches in the repository warm all known caches in the repository
debugupgraderepo debugupgraderepo
upgrade a repository to use different features upgrade a repository to use different features
debugwalk show how files match on given patterns debugwalk show how files match on given patterns
debugwireargs debugwireargs
(no help text available) (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) (use 'hg help -v debug' to show built-in aliases and global options)
internals topic renders index of available sub-topics internals topic renders index of available sub-topics
$ hg help internals $ hg help internals
Technical implementation topics Technical implementation topics
""""""""""""""""""""""""""""""" """""""""""""""""""""""""""""""

tests/test-ssh-proto.t

$ cat >> $HGRCPATH << EOF $ cat >> $HGRCPATH << EOF
> [ui] > [ui]
> ssh = $PYTHON "$TESTDIR/dummyssh" > ssh = $PYTHON "$TESTDIR/dummyssh"
> [devel] > [devel]
> debug.peer-request = true > debug.peer-request = true
> [extensions] > [extensions]
> sshprotoext = $TESTDIR/sshprotoext.py > sshprotoext = $TESTDIR/sshprotoext.py
> EOF > EOF
$ hg init server $ hg init server
$ cd server $ cd server
$ echo 0 > foo $ echo 0 > foo
$ hg -q add foo $ hg -q add foo
$ hg commit -m initial $ 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 Test a normal behaving server, for sanity
$ cd ..
$ hg --debug debugpeer ssh://user@dummy/server $ 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) (no-windows !)
running * "*\tests/dummyssh" "user@dummy" "hg -R server serve --stdio" (glob) (windows !) running * "*\tests/dummyssh" "user@dummy" "hg -R server serve --stdio" (glob) (windows !)
devel-peer-request: hello devel-peer-request: hello
sending hello command sending hello command
devel-peer-request: between devel-peer-request: between
devel-peer-request: pairs: 81 bytes devel-peer-request: pairs: 81 bytes
sending between command sending between command
remote: 384 remote: 384
remote: capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN remote: capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
remote: 1 remote: 1
url: ssh://user@dummy/server url: ssh://user@dummy/server
local: no local: no
pushable: yes pushable: yes
Server should answer the "hello" command in isolation Server should answer the "hello" command in isolation
$ hg -R server serve --stdio << EOF $ hg -R server debugwireproto --localssh --peer raw << EOF
> hello > raw
> EOF > hello\n
384 > readline
capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN > readline
> EOF
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 `hg debugserve --sshstdio` works
$ cd server $ cd server
$ hg debugserve --sshstdio << EOF $ hg debugserve --sshstdio << EOF
> hello > hello
> EOF > EOF
384 384
o> flush() -> None o> flush() -> None
$ cd .. $ cd ..
>=0.9.1 clients send a "hello" + "between" for the null range as part of handshake. >=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 Server should reply with capabilities and should send "1\n\n" as a successful
reply with empty response to the "between". reply with empty response to the "between".
$ hg -R server serve --stdio << EOF $ hg -R server debugwireproto --localssh --peer raw << EOF
> hello > raw
> between > hello\n
> pairs 81 > readline
> readline
> raw
> between\n
> pairs 81\n
> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
> readline
> readline
> EOF > EOF
384 using raw connection to peer
capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN i> write(6) -> None:
1 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 SSH banner is not printed by default, ignored by clients
$ SSHSERVERMODE=banner hg debugpeer ssh://user@dummy/server $ SSHSERVERMODE=banner hg debugpeer ssh://user@dummy/server
url: ssh://user@dummy/server url: ssh://user@dummy/server
local: no local: no
pushable: yes pushable: yes
remote: capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN remote: capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
remote: 1 remote: 1
url: ssh://user@dummy/server url: ssh://user@dummy/server
local: no local: no
pushable: yes pushable: yes
And test the banner with the raw protocol And test the banner with the raw protocol
$ SSHSERVERMODE=banner hg -R server serve --stdio << EOF $ SSHSERVERMODE=banner hg -R server debugwireproto --localssh --peer raw << EOF
> hello > raw
> between > hello\n
> pairs 81 > readline
> readline
> readline
> readline
> readline
> readline
> readline
> readline
> readline
> readline
> readline
> readline
> raw
> between\n
> pairs 81\n
> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
> readline
> readline
> EOF > EOF
banner: line 0 using raw connection to peer
banner: line 1 i> write(6) -> None:
banner: line 2 i> hello\n
banner: line 3 o> readline() -> 15:
banner: line 4 o> banner: line 0\n
banner: line 5 o> readline() -> 15:
banner: line 6 o> banner: line 1\n
banner: line 7 o> readline() -> 15:
banner: line 8 o> banner: line 2\n
banner: line 9 o> readline() -> 15:
384 o> banner: line 3\n
capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN o> readline() -> 15:
1 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. 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 The client should refuse, as we dropped support for connecting to such
servers. servers.
$ SSHSERVERMODE=no-hello hg --debug debugpeer ssh://user@dummy/server $ SSHSERVERMODE=no-hello 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) (no-windows !)
running * "*\tests/dummyssh" "user@dummy" "hg -R server serve --stdio" (glob) (windows !) running * "*\tests/dummyssh" "user@dummy" "hg -R server serve --stdio" (glob) (windows !)
devel-peer-request: hello devel-peer-request: hello
sending hello command sending hello command
devel-peer-request: between devel-peer-request: between
devel-peer-request: pairs: 81 bytes devel-peer-request: pairs: 81 bytes
sending between command sending between command
remote: 0 remote: 0
remote: 1 remote: 1
abort: no suitable response from remote hg! abort: no suitable response from remote hg!
[255] [255]
Sending an unknown command to the server results in an empty response to that command Sending an unknown command to the server results in an empty response to that command
$ hg -R server serve --stdio << EOF $ hg -R server debugwireproto --localssh --peer raw << EOF
> pre-hello > raw
> hello > pre-hello\n
> between > readline
> pairs 81 > raw
> hello\n
> readline
> raw
> between\n
> pairs 81\n
> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
> readline
> readline
> EOF > EOF
0 using raw connection to peer
384 i> write(10) -> None:
capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN i> pre-hello\n
1 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 $ 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 !) 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 !) running * "*\tests/dummyssh" "user@dummy" "hg -R server serve --stdio" (glob) (windows !)
sending no-args command sending no-args command
devel-peer-request: hello devel-peer-request: hello
sending hello command sending hello command
devel-peer-request: between devel-peer-request: between
devel-peer-request: pairs: 81 bytes devel-peer-request: pairs: 81 bytes
sending between command sending between command
remote: 0 remote: 0
remote: 384 remote: 384
remote: capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN remote: capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
remote: 1 remote: 1
url: ssh://user@dummy/server url: ssh://user@dummy/server
local: no local: no
pushable: yes pushable: yes
Send multiple unknown commands before hello Send multiple unknown commands before hello
$ hg -R server serve --stdio << EOF $ hg -R server debugwireproto --localssh --peer raw << EOF
> unknown1 > raw
> unknown2 > unknown1\n
> unknown3 > readline
> hello > raw
> between > unknown2\n
> pairs 81 > readline
> raw
> unknown3\n
> readline
> raw
> hello\n
> readline
> readline
> raw
> between\n
> pairs 81\n
> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
> readline
> readline
> EOF > EOF
0 using raw connection to peer
0 i> write(9) -> None:
0 i> unknown1\n
384 o> readline() -> 2:
capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN o> 0\n
1 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 $ 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 !) 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 !) running * "*\tests/dummyssh" "user@dummy" "hg -R server serve --stdio" (glob) (windows !)
sending unknown1 command sending unknown1 command
sending unknown2 command sending unknown2 command
sending unknown3 command sending unknown3 command
devel-peer-request: hello devel-peer-request: hello
sending hello command sending hello command
devel-peer-request: between devel-peer-request: between
devel-peer-request: pairs: 81 bytes devel-peer-request: pairs: 81 bytes
sending between command sending between command
remote: 0 remote: 0
remote: 0 remote: 0
remote: 0 remote: 0
remote: 384 remote: 384
remote: capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN remote: capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
remote: 1 remote: 1
url: ssh://user@dummy/server url: ssh://user@dummy/server
local: no local: no
pushable: yes pushable: yes
Send an unknown command before hello that has arguments Send an unknown command before hello that has arguments
$ hg -R server serve --stdio << EOF $ cd server
> with-args
> foo 13 $ hg debugwireproto --localssh --peer raw << EOF
> value for foo > raw
> bar 13 > with-args\n
> value for bar > foo 13\n
> hello > value for foo\n
> between > bar 13\n
> pairs 81 > value for bar\n
> readline
> readline
> readline
> readline
> readline
> raw
> hello\n
> readline
> readline
> raw
> between\n
> pairs 81\n
> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
> readline
> readline
> EOF > EOF
0 using raw connection to peer
0 i> write(52) -> None:
0 i> with-args\n
0 i> foo 13\n
0 i> value for foo\n
384 i> bar 13\n
capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN i> value for bar\n
1 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 Send an unknown command having an argument that looks numeric
$ hg -R server serve --stdio << EOF $ hg debugwireproto --localssh --peer raw << EOF
> unknown > raw
> foo 1 > unknown\n
> 0 > foo 1\n
> hello > 0\n
> between > readline
> pairs 81 > readline
> readline
> raw
> hello\n
> readline
> readline
> raw
> between\n
> pairs 81\n
> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
> readline
> readline
> EOF > EOF
0 using raw connection to peer
0 i> write(16) -> None:
0 i> unknown\n
384 i> foo 1\n
capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN i> 0\n
1 o> readline() -> 2:
o> 0\n
o> readline() -> 2:
$ hg -R server serve --stdio << EOF o> 0\n
> unknown o> readline() -> 2:
> foo 1 o> 0\n
> 1 i> write(6) -> None:
> hello i> hello\n
> between o> readline() -> 4:
> pairs 81 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 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 > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
> readline
> readline
> EOF > EOF
0 using raw connection to peer
0 i> write(16) -> None:
0 i> unknown\n
384 i> foo 1\n
capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN i> 1\n
1 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 When sending a dict argument value, it is serialized to
"<arg> <item count>" followed by "<key> <len>\n<value>" for each item "<arg> <item count>" followed by "<key> <len>\n<value>" for each item
in the dict. in the dict.
Dictionary value for unknown command Dictionary value for unknown command
$ hg -R server serve --stdio << EOF $ hg debugwireproto --localssh --peer raw << EOF
> unknown > raw
> dict 3 > unknown\n
> key1 3 > dict 3\n
> foo > key1 3\n
> key2 3 > foo\n
> bar > key2 3\n
> key3 3 > bar\n
> baz > key3 3\n
> hello > baz\n
> EOF > readline
0 > readline
0 > readline
0 > readline
0 > readline
0 > readline
0 > readline
0 > readline
0 > raw
384 > hello\n
capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN > readline
> readline
> EOF
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 Incomplete dictionary send
$ hg -R server serve --stdio << EOF $ hg debugwireproto --localssh --peer raw << EOF
> unknown > raw
> dict 3 > unknown\n
> key1 3 > dict 3\n
> foo > key1 3\n
> EOF > foo\n
0 > readline
0 > readline
0 > readline
0 > readline
> EOF
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 Incomplete value send
$ hg -R server serve --stdio << EOF $ hg debugwireproto --localssh --peer raw << EOF
> unknown > raw
> dict 3 > unknown\n
> key1 3 > dict 3\n
> key1 3\n
> fo > fo
> EOF > readline
0 > readline
0 > readline
0 > EOF
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 Send a command line with spaces
$ hg -R server serve --stdio << EOF $ hg debugwireproto --localssh --peer raw << EOF
> unknown withspace > raw
> hello > unknown withspace\n
> between > readline
> pairs 81 > raw
> hello\n
> readline
> readline
> raw
> between\n
> pairs 81\n
> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
> readline
> readline
> EOF > EOF
0 using raw connection to peer
384 i> write(18) -> None:
capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN i> unknown withspace\n
1 o> readline() -> 2:
o> 0\n
i> write(6) -> None:
$ hg -R server serve --stdio << EOF i> hello\n
> unknown with multiple spaces o> readline() -> 4:
> hello o> 384\n
> between o> readline() -> 384:
> pairs 81 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 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 > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
> readline
> EOF > EOF
0 using raw connection to peer
384 i> write(29) -> None:
capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN i> unknown with multiple spaces\n
1 o> readline() -> 2:
o> 0\n
i> write(6) -> None:
$ hg -R server serve --stdio << EOF i> hello\n
> unknown with spaces o> readline() -> 4:
> key 10 o> 384\n
> some value o> readline() -> 384:
> hello o> capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN\n
> between i> write(98) -> None:
> pairs 81 i> between\n
i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
o> readline() -> 2:
o> 1\n
$ 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 > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
> readline
> readline
> EOF > EOF
0 using raw connection to peer
0 i> write(38) -> None:
0 i> unknown with spaces\n
384 i> key 10\n
capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN i> some value\n
1 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" Send an unknown command after the "between"
$ hg -R server serve --stdio << EOF $ hg debugwireproto --localssh --peer raw << EOF
> hello > raw
> between > hello\n
> pairs 81 > readline
> readline
> raw
> between\n
> pairs 81\n
> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000unknown > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000unknown
> readline
> readline
> EOF > EOF
384 using raw connection to peer
capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN i> write(6) -> None:
1 i> hello\n
o> readline() -> 4:
0 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 And one with arguments
$ hg -R server serve --stdio << EOF $ hg debugwireproto --localssh --peer raw << EOF
> hello > raw
> between > hello\n
> pairs 81 > between\n
> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000unknown > pairs 81\n
> foo 5 > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
> value > readline
> bar 3 > readline
> baz > readline
> EOF > readline
384 > raw
capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN > unknown\n
1 > foo 5\n
> \nvalue\n
0 > bar 3\n
0 > baz\n
0 > readline
0 > readline
0 > readline
> EOF
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 Send a valid command before the handshake
$ hg -R server serve --stdio << EOF $ hg debugwireproto --localssh --peer raw << EOF
> heads > raw
> hello > heads\n
> between > readline
> pairs 81 > raw
> hello\n
> between\n
> pairs 81\n
> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
> EOF > readline
41 > readline
68986213bd4485ea51533535e3fc9e78007a711f > readline
384 > readline
capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN > EOF
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 And a variation that doesn't send the between command
$ hg -R server serve --stdio << EOF $ hg debugwireproto --localssh --peer raw << EOF
> heads > raw
> hello > heads\n
> EOF > readline
41 > raw
68986213bd4485ea51533535e3fc9e78007a711f > hello\n
384 > readline
capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN > readline
> EOF
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 Send an upgrade request to a server that doesn't support that command
$ hg -R server serve --stdio << EOF $ hg debugwireproto --localssh --peer raw << EOF
> upgrade 2e82ab3f-9ce3-4b4e-8f8c-6fd1c0e9e23a proto=irrelevant1%2Cirrelevant2 > raw
> hello > upgrade 2e82ab3f-9ce3-4b4e-8f8c-6fd1c0e9e23a proto=irrelevant1%2Cirrelevant2\n
> between > readline
> pairs 81 > raw
> hello\n
> between\n
> pairs 81\n
> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
> EOF > readline
0 > readline
384 > readline
capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN > readline
1 > EOF
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 $ 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 !) 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 !) running * "*\tests/dummyssh" "user@dummy" "hg -R server serve --stdio" (glob) (windows !)
sending upgrade request: * proto=exp-ssh-v2-0001 (glob) sending upgrade request: * proto=exp-ssh-v2-0001 (glob)
devel-peer-request: hello devel-peer-request: hello
sending hello command sending hello command
devel-peer-request: between devel-peer-request: between
$ cat >> server/.hg/hgrc << EOF $ cat >> server/.hg/hgrc << EOF
> [experimental] > [experimental]
> sshserver.support-v2 = true > sshserver.support-v2 = true
> EOF > EOF
Send an upgrade request to a server that supports upgrade Send an upgrade request to a server that supports upgrade
>>> with open('payload', 'wb') as fh: $ cd server
... fh.write(b'upgrade this-is-some-token proto=exp-ssh-v2-0001\n')
... fh.write(b'hello\n') $ hg debugwireproto --localssh --peer raw << EOF
... fh.write(b'between\n') > raw
... fh.write(b'pairs 81\n') > upgrade this-is-some-token proto=exp-ssh-v2-0001\n
... fh.write(b'0000000000000000000000000000000000000000-0000000000000000000000000000000000000000') > hello\n
> between\n
$ hg -R server serve --stdio < payload > pairs 81\n
upgraded this-is-some-token exp-ssh-v2-0001 > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
383 > readline
capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN > 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 $ 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 !) 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 !) running * "*\tests/dummyssh" "user@dummy" "hg -R server serve --stdio" (glob) (windows !)
sending upgrade request: * proto=exp-ssh-v2-0001 (glob) sending upgrade request: * proto=exp-ssh-v2-0001 (glob)
devel-peer-request: hello devel-peer-request: hello
sending hello command sending hello command
devel-peer-request: between devel-peer-request: between
heads heads
pushkey pushkey
remote-changegroup remote-changegroup
http http
https https
Command after upgrade to version 2 is processed Command after upgrade to version 2 is processed
>>> with open('payload', 'wb') as fh: $ cd server
... 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
Multiple upgrades is not allowed $ 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
>>> with open('payload', 'wb') as fh: Multiple upgrades is not allowed
... 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) Malformed upgrade request line (not exactly 3 space delimited tokens)
$ hg -R server serve --stdio << EOF $ hg debugwireproto --localssh --peer raw << EOF
> upgrade > raw
> EOF > upgrade\n
0 > readline
> EOF
$ hg -R server serve --stdio << EOF using raw connection to peer
> upgrade token i> write(8) -> None:
> EOF i> upgrade\n
0 o> readline() -> 2:
o> 0\n
$ hg -R server serve --stdio << EOF
> upgrade token foo=bar extra-token $ hg debugwireproto --localssh --peer raw << EOF
> EOF > raw
0 > upgrade token\n
> readline
> EOF
using raw connection to peer
i> write(14) -> None:
i> upgrade token\n
o> readline() -> 2:
o> 0\n
$ hg debugwireproto --localssh --peer raw << EOF
> raw
> upgrade token foo=bar extra-token\n
> readline
> EOF
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 Upgrade request to unsupported protocol is ignored
$ hg -R server serve --stdio << EOF $ hg debugwireproto --localssh --peer raw << EOF
> upgrade this-is-some-token proto=unknown1,unknown2 > raw
> hello > upgrade this-is-some-token proto=unknown1,unknown2\n
> between > readline
> pairs 81 > raw
> hello\n
> readline
> readline
> raw
> between\n
> pairs 81\n
> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
> readline
> readline
> EOF > EOF
0 using raw connection to peer
384 i> write(51) -> None:
capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN i> upgrade this-is-some-token proto=unknown1,unknown2\n
1 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 Upgrade request must be followed by hello + between
$ hg -R server serve --stdio << EOF $ hg debugwireproto --localssh --peer raw << EOF
> upgrade token proto=exp-ssh-v2-0001 > raw
> invalid > upgrade token proto=exp-ssh-v2-0001\n
> EOF > invalid\n
malformed handshake protocol: missing hello > readline
- > readavailable
> EOF
using raw connection to peer
$ hg -R server serve --stdio << EOF i> write(44) -> None:
> upgrade token proto=exp-ssh-v2-0001 i> upgrade token proto=exp-ssh-v2-0001\n
> hello i> invalid\n
> invalid o> readline() -> 1:
> EOF o> \n
malformed handshake protocol: missing between e> read(-1) -> 46:
- e> malformed handshake protocol: missing hello\n
e> -\n
$ hg -R server serve --stdio << EOF $ hg debugwireproto --localssh --peer raw << EOF
> upgrade token proto=exp-ssh-v2-0001 > raw
> hello > upgrade token proto=exp-ssh-v2-0001\n
> between > hello\n
> invalid > invalid\n
> EOF > readline
malformed handshake protocol: missing pairs 81 > readavailable
- > EOF
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 debugwireproto --localssh --peer raw << EOF
> raw
> upgrade token proto=exp-ssh-v2-0001\n
> hello\n
> between\n
> invalid\n
> readline
> readavailable
> EOF
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