This is an archive of the discontinued Mercurial Phabricator instance.

Differential D1944

wireproto: provide accessors for client capabilities
ClosedPublic

Authored by joerg.sonnenberger on Jan 27 2018, 8:16 PM.

Details

Reviewers
indygreg
Group Reviewers
hg-reviewers
Commits
rHGafcfdf53e4b5: wireproto: provide accessors for client capabilities
Summary

For HTTP, this refactors the existing logic, including the parsing of
the compression engine capability.

For SSH, this adds a ssh-only capability "protocaps" and a command for
informing the server on what the client supports. Since SSH is stateful,
keep track of the capabilities in the server instance.

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

joerg.sonnenberger added inline comments.Jan 27 2018, 9:01 PM
mercurial/sshserver.py
74 ↗(On Diff #5011)

So this function triggers the underscore function name check, even if the support for this kind of naming is pre-existing. Since the old instances are no longer relevant, renaming the callback would be an option too.

mharbison72 added a subscriber: mharbison72.Jan 28 2018, 1:36 AM
mharbison72 added inline comments.
mercurial/sshserver.py
74 ↗(On Diff #5011)

See bf2db35a6fe7 for an example of # no-check-commit.

joerg.sonnenberger added inline comments.Jan 28 2018, 6:49 AM
mercurial/sshserver.py
74 ↗(On Diff #5011)

Thanks, that answers half of the question. This is an internal interface contract, it could be adjusted as well or replaced with an explicit dictionary. I have no preference for what is cleaner.

indygreg added a subscriber: indygreg.Jan 30 2018, 7:47 PM

I've already started work on a ground-up rewrite of the wire protocol. I hope to start sending patches on Thursday when the 4.6 release window opens.

I hate to spew "stop energy," but I'm hesitant to accept any new additions to the existing wire protocol given a new protocol will soon emerge. The feature in this patch is useful. And I will try to work it into my patches. At the very least, I'll keep it in the back of my mind as I'm designing things. The new wire protocol won't be set in stone from day 0 and we should be able to change it throughout the 4.6 cycle. So there will be plenty of time for bikeshedding and enhancements in the weeks ahead.

indygreg requested changes to this revision.Apr 4 2018, 6:55 PM

I'm OK with the general approach. But this requires a handful of changes before it can be accepted.

For protocol version 2, I plan to send client capabilities as part of the command request. Now that we are using CBOR for command requests, it will be trivial to add client capabilities to the request. We will redundantly send capabilities as part of multiple requests. But since we can have an active compression context in use across command requests, the wire overhead will be negligible. So I'm not worried about the overhead. I care more about making server-side command handlers stateless, as that will make it easier to implement alternate servers.

mercurial/help/internals/wireprotocol.txt
391–393

This should be in the SSH Version 1 Transport section below, because I don't intent to carry this stateful feature forward to protocol version 2.

Also, the new capability should be documented in the capabilities section in this document.

mercurial/wireproto.py
875–877

The protocol handler class in wireprotoserver.py now has an addcapabilities() that should be used for adding transport-specific capabilities. Please use it.

1042

Please define this as transportpolicy=POLICY_V1_ONLY.

Also, please add documentation for the new command to wireprotocol.txt.

1044–1045

The transport filtering isn't necessary if this is implemented differently. Yes, we could expose the command to HTTP. It shouldn't matter.

Also, please set this on proto instead because it is the most appropriate place to define this. The protocol handler's lifetime is per connection for SSH and per-request for HTTP. The repository instance can outlive the HTTP request and the HTTP/SSH connection and it therefore isn't an appropriate place.

mercurial/wireprotoserver.py
594

Please remove this, as we won't carry this implementation forward to version 2.

610–613

And have this return an empty set for now.

This revision now requires changes to proceed.Apr 4 2018, 6:55 PM
joerg.sonnenberger marked 6 inline comments as done.Apr 5 2018, 7:20 AM
indygreg accepted this revision.Apr 6 2018, 1:26 PM

This looks great! It adds some much needed parity between the existing SSH and HTTP transports.

This revision is now accepted and ready to land.Apr 6 2018, 1:26 PM
Closed by commit rHGafcfdf53e4b5: wireproto: provide accessors for client capabilities (authored by joerg.sonnenberger). · Explain WhyApr 6 2018, 1:27 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 7786

mercurial/help/internals/wireprotocol.txt

The client-issued token that is echoed in the response provides a more The client-issued token that is echoed in the response provides a more
resilient mechanism for differentiating *banner* output from Mercurial resilient mechanism for differentiating *banner* output from Mercurial
output. In version 1, properly formatted banner output could get confused output. In version 1, properly formatted banner output could get confused
for Mercurial server output. By submitting a randomly generated token for Mercurial server output. By submitting a randomly generated token
that is then present in the response, the client can look for that token that is then present in the response, the client can look for that token
in response lines and have reasonable certainty that the line did not in response lines and have reasonable certainty that the line did not
originate from a *banner* message. originate from a *banner* message.
SSH Version 1 Transport SSH Version 1 Transport
----------------------- -----------------------
indygregUnsubmitted
Done

This should be in the SSH Version 1 Transport section below, because I don't intent to carry this stateful feature forward to protocol version 2.

Also, the new capability should be documented in the capabilities section in this document.

indygreg: This should be in the `SSH Version 1 Transport` section below, because I don't intent to carry…
The SSH transport (version 1) is a custom text-based protocol suitable for The SSH transport (version 1) is a custom text-based protocol suitable for
use over any bi-directional stream transport. It is most commonly used with use over any bi-directional stream transport. It is most commonly used with
SSH. SSH.
A SSH transport server can be started with ``hg serve --stdio``. The stdin, A SSH transport server can be started with ``hg serve --stdio``. The stdin,
stderr, and stdout file descriptors of the started process are used to exchange stderr, and stdout file descriptors of the started process are used to exchange
data. When Mercurial connects to a remote server over SSH, it actually starts data. When Mercurial connects to a remote server over SSH, it actually starts
a ``hg serve --stdio`` process on the remote server. a ``hg serve --stdio`` process on the remote server.
message written to ``stderr`` followed by ``\n-\n``. In addition, ``\n`` is message written to ``stderr`` followed by ``\n-\n``. In addition, ``\n`` is
written to ``stdout``. written to ``stdout``.
If the server receives an unknown command, it will send an empty ``string`` If the server receives an unknown command, it will send an empty ``string``
response. response.
The server terminates if it receives an empty command (a ``\n`` character). The server terminates if it receives an empty command (a ``\n`` character).
If the server announces support for the ``protocaps`` capability, the client
should issue a ``protocaps`` command after the initial handshake to annonunce
its own capabilities. The client capabilities are persistent.
SSH Version 2 Transport SSH Version 2 Transport
----------------------- -----------------------
**Experimental and under development** **Experimental and under development**
Version 2 of the SSH transport behaves identically to version 1 of the SSH Version 2 of the SSH transport behaves identically to version 1 of the SSH
transport with the exception of handshake semantics. See above for how transport with the exception of handshake semantics. See above for how
version 2 of the SSH transport is negotiated. version 2 of the SSH transport is negotiated.
Whether the server supports the ``lookup`` command. Whether the server supports the ``lookup`` command.
This capability was introduced in Mercurial 0.9.2 (released December This capability was introduced in Mercurial 0.9.2 (released December
2006). 2006).
This capability was introduced at the same time as the ``changegroupsubset`` This capability was introduced at the same time as the ``changegroupsubset``
capability/command. capability/command.
protocaps
---------
Whether the server supports the ``protocaps`` command for SSH V1 transport.
This capability was introduced in Mercurial 4.6.
pushkey pushkey
------- -------
Whether the server supports the ``pushkey`` and ``listkeys`` commands. Whether the server supports the ``pushkey`` and ``listkeys`` commands.
This capability was introduced in Mercurial 1.6 (released July 2010). This capability was introduced in Mercurial 1.6 (released July 2010).
standardbundle standardbundle
Returns a string consisting of ``0``s and ``1``s indicating whether nodes Returns a string consisting of ``0``s and ``1``s indicating whether nodes
are known. If the Nth node specified in the ``nodes`` argument is known, are known. If the Nth node specified in the ``nodes`` argument is known,
a ``1`` will be returned at byte offset N. If the node isn't known, ``0`` a ``1`` will be returned at byte offset N. If the node isn't known, ``0``
will be present at byte offset N. will be present at byte offset N.
There is no trailing newline. There is no trailing newline.
protocaps
---------
Notify the server about the client capabilities in the SSH V1 transport
protocol.
The ``caps`` argument is a space-delimited list of capabilities.
The server will reply with the string ``OK``.
pushkey pushkey
------- -------
Set a value using the ``pushkey`` protocol. Set a value using the ``pushkey`` protocol.
Accepts arguments ``namespace``, ``key``, ``old``, and ``new``, which Accepts arguments ``namespace``, ``key``, ``old``, and ``new``, which
correspond to the pushkey namespace to operate on, the key within that correspond to the pushkey namespace to operate on, the key within that
namespace to change, the old value (which may be empty), and the new value. namespace to change, the old value (which may be empty), and the new value.

mercurial/sshpeer.py

# no buffer allow the use of 'select' # no buffer allow the use of 'select'
# feel free to remove buffering and select usage when we ultimately # feel free to remove buffering and select usage when we ultimately
# move to threading. # move to threading.
stdin, stdout, stderr, proc = procutil.popen4(cmd, bufsize=0, env=sshenv) stdin, stdout, stderr, proc = procutil.popen4(cmd, bufsize=0, env=sshenv)
return proc, stdin, stdout, stderr return proc, stdin, stdout, stderr
def _clientcapabilities():
"""Return list of capabilities of this client.
Returns a list of capabilities that are supported by this client.
"""
protoparams = []
comps = [e.wireprotosupport().name for e in
util.compengines.supportedwireengines(util.CLIENTROLE)]
protoparams.append('comp=%s' % ','.join(comps))
return protoparams
def _performhandshake(ui, stdin, stdout, stderr): def _performhandshake(ui, stdin, stdout, stderr):
def badresponse(): def badresponse():
# Flush any output on stderr. # Flush any output on stderr.
_forwardoutput(ui, stderr) _forwardoutput(ui, stderr)
msg = _('no suitable response from remote hg') msg = _('no suitable response from remote hg')
hint = ui.config('ui', 'ssherrorhint') hint = ui.config('ui', 'ssherrorhint')
raise error.RepoError(msg, hint=hint) raise error.RepoError(msg, hint=hint)
ui.debug('running %s\n' % cmd) ui.debug('running %s\n' % cmd)
res = ui.system(cmd, blockedtag='sshpeer', environ=sshenv) res = ui.system(cmd, blockedtag='sshpeer', environ=sshenv)
if res != 0: if res != 0:
raise error.RepoError(_('could not create remote repo')) raise error.RepoError(_('could not create remote repo'))
proc, stdin, stdout, stderr = _makeconnection(ui, sshcmd, args, remotecmd, proc, stdin, stdout, stderr = _makeconnection(ui, sshcmd, args, remotecmd,
remotepath, sshenv) remotepath, sshenv)
return makepeer(ui, path, proc, stdin, stdout, stderr) peer = makepeer(ui, path, proc, stdin, stdout, stderr)
# Finally, if supported by the server, notify it about our own
# capabilities.
if 'protocaps' in peer.capabilities():
try:
peer._call("protocaps", caps=' '.join(_clientcapabilities()))
except IOError:
peer._cleanup()
raise error.RepoError(_('capability exchange failed'))
return peer

mercurial/wireproto.py

assert all(escapearg(k) == k for k in argsdict) assert all(escapearg(k) == k for k in argsdict)
args = ','.join('%s=%s' % (escapearg(k), escapearg(v)) args = ','.join('%s=%s' % (escapearg(k), escapearg(v))
for k, v in argsdict.iteritems()) for k, v in argsdict.iteritems())
cmds.append('%s %s' % (op, args)) cmds.append('%s %s' % (op, args))
return ';'.join(cmds) return ';'.join(cmds)
def clientcompressionsupport(proto):
"""Returns a list of compression methods supported by the client.
Returns a list of the compression methods supported by the client
according to the protocol capabilities. If no such capability has
been announced, fallback to the default of zlib and uncompressed.
"""
for cap in proto.getprotocaps():
if cap.startswith('comp='):
return cap[5:].split(',')
return ['zlib', 'none']
# mapping of options accepted by getbundle and their types # mapping of options accepted by getbundle and their types
# #
# Meant to be extended by extensions. It is extensions responsibility to ensure # Meant to be extended by extensions. It is extensions responsibility to ensure
# such options are properly processed in exchange.getbundle. # such options are properly processed in exchange.getbundle.
# #
# supported types are: # supported types are:
# #
# :nodes: list of binary nodes # :nodes: list of binary nodes
- returns a lists: easy to alter - returns a lists: easy to alter
- change done here will be propagated to both `capabilities` and `hello` - change done here will be propagated to both `capabilities` and `hello`
command without any other action needed. command without any other action needed.
""" """
# copy to prevent modification of the global list # copy to prevent modification of the global list
caps = list(wireprotocaps) caps = list(wireprotocaps)
# Command of same name as capability isn't exposed to version 1 of # Command of same name as capability isn't exposed to version 1 of
# transports. So conditionally add it. # transports. So conditionally add it.
if commands.commandavailable('changegroupsubset', proto): if commands.commandavailable('changegroupsubset', proto):
indygregUnsubmitted
Done

The protocol handler class in wireprotoserver.py now has an addcapabilities() that should be used for adding transport-specific capabilities. Please use it.

indygreg: The protocol handler class in `wireprotoserver.py` now has an `addcapabilities()` that should…
caps.append('changegroupsubset') caps.append('changegroupsubset')
if streamclone.allowservergeneration(repo): if streamclone.allowservergeneration(repo):
if repo.ui.configbool('server', 'preferuncompressed'): if repo.ui.configbool('server', 'preferuncompressed'):
caps.append('stream-preferred') caps.append('stream-preferred')
requiredformats = repo.requirements & repo.supportedformats requiredformats = repo.requirements & repo.supportedformats
# if our local revlogs are just revlogv1, add 'stream' cap # if our local revlogs are just revlogv1, add 'stream' cap
if not requiredformats - {'revlogv1'}: if not requiredformats - {'revlogv1'}:
success = 0 success = 0
return wireprototypes.bytesresponse('%d %s\n' % (success, r)) return wireprototypes.bytesresponse('%d %s\n' % (success, r))
@wireprotocommand('known', 'nodes *', permission='pull') @wireprotocommand('known', 'nodes *', permission='pull')
def known(repo, proto, nodes, others): def known(repo, proto, nodes, others):
v = ''.join(b and '1' or '0' for b in repo.known(decodelist(nodes))) v = ''.join(b and '1' or '0' for b in repo.known(decodelist(nodes)))
return wireprototypes.bytesresponse(v) return wireprototypes.bytesresponse(v)
@wireprotocommand('protocaps', 'caps', permission='pull',
indygregUnsubmitted
Done

Please define this as transportpolicy=POLICY_V1_ONLY.

Also, please add documentation for the new command to wireprotocol.txt.

indygreg: Please define this as `transportpolicy=POLICY_V1_ONLY`. Also, please add documentation for the…
transportpolicy=POLICY_V1_ONLY)
def protocaps(repo, proto, caps):
if proto.name == wireprototypes.SSHV1:
indygregUnsubmitted
Done

The transport filtering isn't necessary if this is implemented differently. Yes, we could expose the command to HTTP. It shouldn't matter.

Also, please set this on proto instead because it is the most appropriate place to define this. The protocol handler's lifetime is per connection for SSH and per-request for HTTP. The repository instance can outlive the HTTP request and the HTTP/SSH connection and it therefore isn't an appropriate place.

indygreg: The transport filtering isn't necessary if this is implemented differently. Yes, we could…
proto._protocaps = set(caps.split(' '))
return wireprototypes.bytesresponse('OK')
@wireprotocommand('pushkey', 'namespace key old new', permission='push') @wireprotocommand('pushkey', 'namespace key old new', permission='push')
def pushkey(repo, proto, namespace, key, old, new): def pushkey(repo, proto, namespace, key, old, new):
# compatibility with pre-1.8 clients which were accidentally # compatibility with pre-1.8 clients which were accidentally
# sending raw binary nodes rather than utf-8-encoded hex # sending raw binary nodes rather than utf-8-encoded hex
if len(new) == 20 and stringutil.escapestr(new) != new: if len(new) == 20 and stringutil.escapestr(new) != new:
# looks like it could be a binary node # looks like it could be a binary node
try: try:
new.decode('utf-8') new.decode('utf-8')

mercurial/wireprotoserver.py

return ''.join(chunks) return ''.join(chunks)
@zi.implementer(wireprototypes.baseprotocolhandler) @zi.implementer(wireprototypes.baseprotocolhandler)
class httpv1protocolhandler(object): class httpv1protocolhandler(object):
def __init__(self, req, ui, checkperm): def __init__(self, req, ui, checkperm):
self._req = req self._req = req
self._ui = ui self._ui = ui
self._checkperm = checkperm self._checkperm = checkperm
self._protocaps = None
@property @property
def name(self): def name(self):
return 'http-v1' return 'http-v1'
def getargs(self, args): def getargs(self, args):
knownargs = self._args() knownargs = self._args()
data = {} data = {}
args.update(urlreq.parseqs( args.update(urlreq.parseqs(
self._req.bodyfh.read(postlen), keep_blank_values=True)) self._req.bodyfh.read(postlen), keep_blank_values=True))
return args return args
argvalue = decodevaluefromheaders(self._req, b'X-HgArg') argvalue = decodevaluefromheaders(self._req, b'X-HgArg')
args.update(urlreq.parseqs(argvalue, keep_blank_values=True)) args.update(urlreq.parseqs(argvalue, keep_blank_values=True))
return args return args
def getprotocaps(self):
if self._protocaps is None:
value = decodevaluefromheaders(self._req, r'X-HgProto')
self._protocaps = set(value.split(' '))
return self._protocaps
def forwardpayload(self, fp): def forwardpayload(self, fp):
# Existing clients *always* send Content-Length. # Existing clients *always* send Content-Length.
length = int(self._req.headers[b'Content-Length']) length = int(self._req.headers[b'Content-Length'])
# If httppostargs is used, we need to read Content-Length # If httppostargs is used, we need to read Content-Length
# minus the amount that was consumed by args. # minus the amount that was consumed by args.
length -= int(self._req.headers.get(b'X-HgArgs-Post', 0)) length -= int(self._req.headers.get(b'X-HgArgs-Post', 0))
for s in util.filechunkiter(self._req.bodyfh, limit=length): for s in util.filechunkiter(self._req.bodyfh, limit=length):
} }
@zi.implementer(wireprototypes.baseprotocolhandler) @zi.implementer(wireprototypes.baseprotocolhandler)
class httpv2protocolhandler(object): class httpv2protocolhandler(object):
def __init__(self, req, ui, args=None): def __init__(self, req, ui, args=None):
self._req = req self._req = req
self._ui = ui self._ui = ui
self._args = args self._args = args
indygregUnsubmitted
Done

Please remove this, as we won't carry this implementation forward to version 2.

indygreg: Please remove this, as we won't carry this implementation forward to version 2.
@property @property
def name(self): def name(self):
return HTTPV2 return HTTPV2
def getargs(self, args): def getargs(self, args):
data = {} data = {}
for k in args.split(): for k in args.split():
if k == '*': if k == '*':
raise NotImplementedError('do not support * args') raise NotImplementedError('do not support * args')
else: else:
data[k] = self._args[k] data[k] = self._args[k]
return [data[k] for k in args.split()] return [data[k] for k in args.split()]
def getprotocaps(self):
# Protocol capabilities are currently not implemented for HTTP V2.
return set()
def forwardpayload(self, fp): def forwardpayload(self, fp):
indygregUnsubmitted
Done

And have this return an empty set for now.

indygreg: And have this return an empty set for now.
raise NotImplementedError raise NotImplementedError
@contextlib.contextmanager @contextlib.contextmanager
def mayberedirectstdio(self): def mayberedirectstdio(self):
raise NotImplementedError raise NotImplementedError
def client(self): def client(self):
raise NotImplementedError raise NotImplementedError
def addcapabilities(self, repo, caps): def addcapabilities(self, repo, caps):
return caps return caps
def checkperm(self, perm): def checkperm(self, perm):
raise NotImplementedError raise NotImplementedError
def _httpresponsetype(ui, req, prefer_uncompressed): def _httpresponsetype(ui, proto, prefer_uncompressed):
"""Determine the appropriate response type and compression settings. """Determine the appropriate response type and compression settings.
Returns a tuple of (mediatype, compengine, engineopts). Returns a tuple of (mediatype, compengine, engineopts).
""" """
# Determine the response media type and compression engine based # Determine the response media type and compression engine based
# on the request parameters. # on the request parameters.
protocaps = decodevaluefromheaders(req, 'X-HgProto').split(' ')
if '0.2' in protocaps: if '0.2' in proto.getprotocaps():
# All clients are expected to support uncompressed data. # All clients are expected to support uncompressed data.
if prefer_uncompressed: if prefer_uncompressed:
return HGTYPE2, util._noopengine(), {} return HGTYPE2, util._noopengine(), {}
# Default as defined by wire protocol spec.
compformats = ['zlib', 'none']
for cap in protocaps:
if cap.startswith('comp='):
compformats = cap[5:].split(',')
break
# Now find an agreed upon compression format. # Now find an agreed upon compression format.
compformats = wireproto.clientcompressionsupport(proto)
for engine in wireproto.supportedcompengines(ui, util.SERVERROLE): for engine in wireproto.supportedcompengines(ui, util.SERVERROLE):
if engine.wireprotosupport().name in compformats: if engine.wireprotosupport().name in compformats:
opts = {} opts = {}
level = ui.configint('server', '%slevel' % engine.name()) level = ui.configint('server', '%slevel' % engine.name())
if level is not None: if level is not None:
opts['level'] = level opts['level'] = level
return HGTYPE2, engine, opts return HGTYPE2, engine, opts
elif isinstance(rsp, wireprototypes.streamreslegacy): elif isinstance(rsp, wireprototypes.streamreslegacy):
setresponse(HTTP_OK, HGTYPE, bodygen=rsp.gen) setresponse(HTTP_OK, HGTYPE, bodygen=rsp.gen)
elif isinstance(rsp, wireprototypes.streamres): elif isinstance(rsp, wireprototypes.streamres):
gen = rsp.gen gen = rsp.gen
# This code for compression should not be streamres specific. It # This code for compression should not be streamres specific. It
# is here because we only compress streamres at the moment. # is here because we only compress streamres at the moment.
mediatype, engine, engineopts = _httpresponsetype( mediatype, engine, engineopts = _httpresponsetype(
repo.ui, req, rsp.prefer_uncompressed) repo.ui, proto, rsp.prefer_uncompressed)
gen = engine.compressstream(gen, engineopts) gen = engine.compressstream(gen, engineopts)
if mediatype == HGTYPE2: if mediatype == HGTYPE2:
gen = genversion2(gen, engine, engineopts) gen = genversion2(gen, engine, engineopts)
setresponse(HTTP_OK, mediatype, bodygen=gen) setresponse(HTTP_OK, mediatype, bodygen=gen)
elif isinstance(rsp, wireprototypes.pushres): elif isinstance(rsp, wireprototypes.pushres):
rsp = '%d\n%s' % (rsp.res, rsp.output) rsp = '%d\n%s' % (rsp.res, rsp.output)
@zi.implementer(wireprototypes.baseprotocolhandler) @zi.implementer(wireprototypes.baseprotocolhandler)
class sshv1protocolhandler(object): class sshv1protocolhandler(object):
"""Handler for requests services via version 1 of SSH protocol.""" """Handler for requests services via version 1 of SSH protocol."""
def __init__(self, ui, fin, fout): def __init__(self, ui, fin, fout):
self._ui = ui self._ui = ui
self._fin = fin self._fin = fin
self._fout = fout self._fout = fout
self._protocaps = set()
@property @property
def name(self): def name(self):
return wireprototypes.SSHV1 return wireprototypes.SSHV1
def getargs(self, args): def getargs(self, args):
data = {} data = {}
keys = args.split() keys = args.split()
val = self._fin.read(int(l)) val = self._fin.read(int(l))
star[arg] = val star[arg] = val
data['*'] = star data['*'] = star
else: else:
val = self._fin.read(int(l)) val = self._fin.read(int(l))
data[arg] = val data[arg] = val
return [data[k] for k in keys] return [data[k] for k in keys]
def getprotocaps(self):
return self._protocaps
def forwardpayload(self, fpout): def forwardpayload(self, fpout):
# We initially send an empty response. This tells the client it is # We initially send an empty response. This tells the client it is
# OK to start sending data. If a client sees any other response, it # OK to start sending data. If a client sees any other response, it
# interprets it as an error. # interprets it as an error.
_sshv1respondbytes(self._fout, b'') _sshv1respondbytes(self._fout, b'')
# The file is in the form: # The file is in the form:
# #
def mayberedirectstdio(self): def mayberedirectstdio(self):
yield None yield None
def client(self): def client(self):
client = encoding.environ.get('SSH_CLIENT', '').split(' ', 1)[0] client = encoding.environ.get('SSH_CLIENT', '').split(' ', 1)[0]
return 'remote:ssh:' + client return 'remote:ssh:' + client
def addcapabilities(self, repo, caps): def addcapabilities(self, repo, caps):
if self.name == wireprototypes.SSHV1:
caps.append(b'protocaps')
caps.append(b'batch') caps.append(b'batch')
return caps return caps
def checkperm(self, perm): def checkperm(self, perm):
pass pass
class sshv2protocolhandler(sshv1protocolhandler): class sshv2protocolhandler(sshv1protocolhandler):
"""Protocol handler for version 2 of the SSH protocol.""" """Protocol handler for version 2 of the SSH protocol."""

mercurial/wireprototypes.py

Used for uniquely identifying the transport type. Used for uniquely identifying the transport type.
""") """)
def getargs(args): def getargs(args):
"""return the value for arguments in <args> """return the value for arguments in <args>
returns a list of values (same order as <args>)""" returns a list of values (same order as <args>)"""
def getprotocaps():
"""Returns the list of protocol-level capabilities of client
Returns a list of capabilities as declared by the client for
the current request (or connection for stateful protocol handlers)."""
def forwardpayload(fp): def forwardpayload(fp):
"""Read the raw payload and forward to a file. """Read the raw payload and forward to a file.
The payload is read in full before the function returns. The payload is read in full before the function returns.
""" """
def mayberedirectstdio(): def mayberedirectstdio():
"""Context manager to possibly redirect stdio. """Context manager to possibly redirect stdio.

tests/test-debugcommands.t

$ hg --config ui.ssh="\"$PYTHON\" \"$TESTDIR/dummyssh\"" --debug debugpeer ssh://user@dummy/debugrevlog $ hg --config ui.ssh="\"$PYTHON\" \"$TESTDIR/dummyssh\"" --debug debugpeer ssh://user@dummy/debugrevlog
running "*" "*/tests/dummyssh" 'user@dummy' 'hg -R debugrevlog serve --stdio' (glob) (no-windows !) running "*" "*/tests/dummyssh" 'user@dummy' 'hg -R debugrevlog serve --stdio' (glob) (no-windows !)
running "*" "*\tests/dummyssh" "user@dummy" "hg -R debugrevlog serve --stdio" (glob) (windows !) running "*" "*\tests/dummyssh" "user@dummy" "hg -R debugrevlog 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: 403 remote: 413
remote: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch remote: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
remote: 1 remote: 1
devel-peer-request: protocaps
devel-peer-request: caps: * bytes (glob)
sending protocaps command
url: ssh://user@dummy/debugrevlog url: ssh://user@dummy/debugrevlog
local: no local: no
pushable: yes pushable: yes

tests/test-ssh-bundle1.t

debug output debug output
$ hg pull --debug ssh://user@dummy/remote $ hg pull --debug ssh://user@dummy/remote
pulling from ssh://user@dummy/remote pulling from ssh://user@dummy/remote
running .* ".*/dummyssh" ['"]user@dummy['"] ('|")hg -R remote serve --stdio('|") (re) running .* ".*/dummyssh" ['"]user@dummy['"] ('|")hg -R remote serve --stdio('|") (re)
sending upgrade request: * proto=exp-ssh-v2-0001 (glob) (sshv2 !) sending upgrade request: * proto=exp-ssh-v2-0001 (glob) (sshv2 !)
sending hello command sending hello command
sending between command sending between command
remote: 403 (sshv1 !) remote: 413 (sshv1 !)
protocol upgraded to exp-ssh-v2-0001 (sshv2 !) protocol upgraded to exp-ssh-v2-0001 (sshv2 !)
remote: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch remote: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
remote: 1 (sshv1 !) remote: 1 (sshv1 !)
sending protocaps command
preparing listkeys for "bookmarks" preparing listkeys for "bookmarks"
sending listkeys command sending listkeys command
received listkey for "bookmarks": 45 bytes received listkey for "bookmarks": 45 bytes
query 1; heads query 1; heads
sending batch command sending batch command
searching for changes searching for changes
all remote heads known locally all remote heads known locally
no changes found no changes found

tests/test-ssh-proto-unbundle.t

creating ssh peer from handshake results creating ssh peer from handshake results
i> write(104) -> 104: i> write(104) -> 104:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
sending unbundle command sending unbundle command
i> write(9) -> 9: i> write(9) -> 9:
i> unbundle\n i> unbundle\n
i> write(9) -> 9: i> write(9) -> 9:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 62: o> readline() -> 62:
o> upgraded * exp-ssh-v2-0001\n (glob) o> upgraded * exp-ssh-v2-0001\n (glob)
o> readline() -> 4: o> readline() -> 4:
o> 402\n o> 412\n
o> read(402) -> 402: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch o> read(412) -> 412: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
o> read(1) -> 1: o> read(1) -> 1:
o> \n o> \n
sending unbundle command sending unbundle command
i> write(9) -> 9: i> write(9) -> 9:
i> unbundle\n i> unbundle\n
i> write(9) -> 9: i> write(9) -> 9:
i> heads 10\n i> heads 10\n
i> write(10) -> 10: 666f726365 i> write(10) -> 10: 666f726365
creating ssh peer from handshake results creating ssh peer from handshake results
i> write(104) -> 104: i> write(104) -> 104:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
sending unbundle command sending unbundle command
i> write(9) -> 9: i> write(9) -> 9:
i> unbundle\n i> unbundle\n
i> write(9) -> 9: i> write(9) -> 9:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 62: o> readline() -> 62:
o> upgraded * exp-ssh-v2-0001\n (glob) o> upgraded * exp-ssh-v2-0001\n (glob)
o> readline() -> 4: o> readline() -> 4:
o> 402\n o> 412\n
o> read(402) -> 402: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch o> read(412) -> 412: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
o> read(1) -> 1: o> read(1) -> 1:
o> \n o> \n
sending unbundle command sending unbundle command
i> write(9) -> 9: i> write(9) -> 9:
i> unbundle\n i> unbundle\n
i> write(9) -> 9: i> write(9) -> 9:
i> heads 10\n i> heads 10\n
i> write(10) -> 10: 666f726365 i> write(10) -> 10: 666f726365
creating ssh peer from handshake results creating ssh peer from handshake results
i> write(104) -> 104: i> write(104) -> 104:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
sending unbundle command sending unbundle command
i> write(9) -> 9: i> write(9) -> 9:
i> unbundle\n i> unbundle\n
i> write(9) -> 9: i> write(9) -> 9:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 62: o> readline() -> 62:
o> upgraded * exp-ssh-v2-0001\n (glob) o> upgraded * exp-ssh-v2-0001\n (glob)
o> readline() -> 4: o> readline() -> 4:
o> 402\n o> 412\n
o> read(402) -> 402: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch o> read(412) -> 412: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
o> read(1) -> 1: o> read(1) -> 1:
o> \n o> \n
sending unbundle command sending unbundle command
i> write(9) -> 9: i> write(9) -> 9:
i> unbundle\n i> unbundle\n
i> write(9) -> 9: i> write(9) -> 9:
i> heads 10\n i> heads 10\n
i> write(10) -> 10: 666f726365 i> write(10) -> 10: 666f726365
creating ssh peer from handshake results creating ssh peer from handshake results
i> write(104) -> 104: i> write(104) -> 104:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
sending unbundle command sending unbundle command
i> write(9) -> 9: i> write(9) -> 9:
i> unbundle\n i> unbundle\n
i> write(9) -> 9: i> write(9) -> 9:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 62: o> readline() -> 62:
o> upgraded * exp-ssh-v2-0001\n (glob) o> upgraded * exp-ssh-v2-0001\n (glob)
o> readline() -> 4: o> readline() -> 4:
o> 402\n o> 412\n
o> read(402) -> 402: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch o> read(412) -> 412: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
o> read(1) -> 1: o> read(1) -> 1:
o> \n o> \n
sending unbundle command sending unbundle command
i> write(9) -> 9: i> write(9) -> 9:
i> unbundle\n i> unbundle\n
i> write(9) -> 9: i> write(9) -> 9:
i> heads 10\n i> heads 10\n
i> write(10) -> 10: 666f726365 i> write(10) -> 10: 666f726365
creating ssh peer from handshake results creating ssh peer from handshake results
i> write(104) -> 104: i> write(104) -> 104:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
sending unbundle command sending unbundle command
i> write(9) -> 9: i> write(9) -> 9:
i> unbundle\n i> unbundle\n
i> write(9) -> 9: i> write(9) -> 9:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 62: o> readline() -> 62:
o> upgraded * exp-ssh-v2-0001\n (glob) o> upgraded * exp-ssh-v2-0001\n (glob)
o> readline() -> 4: o> readline() -> 4:
o> 402\n o> 412\n
o> read(402) -> 402: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch o> read(412) -> 412: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
o> read(1) -> 1: o> read(1) -> 1:
o> \n o> \n
sending unbundle command sending unbundle command
i> write(9) -> 9: i> write(9) -> 9:
i> unbundle\n i> unbundle\n
i> write(9) -> 9: i> write(9) -> 9:
i> heads 10\n i> heads 10\n
i> write(10) -> 10: 666f726365 i> write(10) -> 10: 666f726365
creating ssh peer from handshake results creating ssh peer from handshake results
i> write(104) -> 104: i> write(104) -> 104:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
sending unbundle command sending unbundle command
i> write(9) -> 9: i> write(9) -> 9:
i> unbundle\n i> unbundle\n
i> write(9) -> 9: i> write(9) -> 9:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 62: o> readline() -> 62:
o> upgraded * exp-ssh-v2-0001\n (glob) o> upgraded * exp-ssh-v2-0001\n (glob)
o> readline() -> 4: o> readline() -> 4:
o> 402\n o> 412\n
o> read(402) -> 402: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch o> read(412) -> 412: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
o> read(1) -> 1: o> read(1) -> 1:
o> \n o> \n
sending unbundle command sending unbundle command
i> write(9) -> 9: i> write(9) -> 9:
i> unbundle\n i> unbundle\n
i> write(9) -> 9: i> write(9) -> 9:
i> heads 10\n i> heads 10\n
i> write(10) -> 10: 666f726365 i> write(10) -> 10: 666f726365
creating ssh peer from handshake results creating ssh peer from handshake results
i> write(104) -> 104: i> write(104) -> 104:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
sending unbundle command sending unbundle command
i> write(9) -> 9: i> write(9) -> 9:
i> unbundle\n i> unbundle\n
i> write(9) -> 9: i> write(9) -> 9:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 62: o> readline() -> 62:
o> upgraded * exp-ssh-v2-0001\n (glob) o> upgraded * exp-ssh-v2-0001\n (glob)
o> readline() -> 4: o> readline() -> 4:
o> 402\n o> 412\n
o> read(402) -> 402: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch o> read(412) -> 412: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
o> read(1) -> 1: o> read(1) -> 1:
o> \n o> \n
sending unbundle command sending unbundle command
i> write(9) -> 9: i> write(9) -> 9:
i> unbundle\n i> unbundle\n
i> write(9) -> 9: i> write(9) -> 9:
i> heads 10\n i> heads 10\n
i> write(10) -> 10: 666f726365 i> write(10) -> 10: 666f726365
creating ssh peer from handshake results creating ssh peer from handshake results
i> write(104) -> 104: i> write(104) -> 104:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
sending unbundle command sending unbundle command
i> write(9) -> 9: i> write(9) -> 9:
i> unbundle\n i> unbundle\n
i> write(9) -> 9: i> write(9) -> 9:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 62: o> readline() -> 62:
o> upgraded * exp-ssh-v2-0001\n (glob) o> upgraded * exp-ssh-v2-0001\n (glob)
o> readline() -> 4: o> readline() -> 4:
o> 402\n o> 412\n
o> read(402) -> 402: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch o> read(412) -> 412: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
o> read(1) -> 1: o> read(1) -> 1:
o> \n o> \n
sending unbundle command sending unbundle command
i> write(9) -> 9: i> write(9) -> 9:
i> unbundle\n i> unbundle\n
i> write(9) -> 9: i> write(9) -> 9:
i> heads 10\n i> heads 10\n
i> write(10) -> 10: 666f726365 i> write(10) -> 10: 666f726365
creating ssh peer from handshake results creating ssh peer from handshake results
i> write(104) -> 104: i> write(104) -> 104:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
sending unbundle command sending unbundle command
i> write(9) -> 9: i> write(9) -> 9:
i> unbundle\n i> unbundle\n
i> write(9) -> 9: i> write(9) -> 9:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 62: o> readline() -> 62:
o> upgraded * exp-ssh-v2-0001\n (glob) o> upgraded * exp-ssh-v2-0001\n (glob)
o> readline() -> 4: o> readline() -> 4:
o> 402\n o> 412\n
o> read(402) -> 402: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch o> read(412) -> 412: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
o> read(1) -> 1: o> read(1) -> 1:
o> \n o> \n
sending unbundle command sending unbundle command
i> write(9) -> 9: i> write(9) -> 9:
i> unbundle\n i> unbundle\n
i> write(9) -> 9: i> write(9) -> 9:
i> heads 10\n i> heads 10\n
i> write(10) -> 10: 666f726365 i> write(10) -> 10: 666f726365
creating ssh peer from handshake results creating ssh peer from handshake results
i> write(104) -> 104: i> write(104) -> 104:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
sending unbundle command sending unbundle command
i> write(9) -> 9: i> write(9) -> 9:
i> unbundle\n i> unbundle\n
i> write(9) -> 9: i> write(9) -> 9:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 62: o> readline() -> 62:
o> upgraded * exp-ssh-v2-0001\n (glob) o> upgraded * exp-ssh-v2-0001\n (glob)
o> readline() -> 4: o> readline() -> 4:
o> 402\n o> 412\n
o> read(402) -> 402: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch o> read(412) -> 412: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
o> read(1) -> 1: o> read(1) -> 1:
o> \n o> \n
sending unbundle command sending unbundle command
i> write(9) -> 9: i> write(9) -> 9:
i> unbundle\n i> unbundle\n
i> write(9) -> 9: i> write(9) -> 9:
i> heads 10\n i> heads 10\n
i> write(10) -> 10: 666f726365 i> write(10) -> 10: 666f726365
creating ssh peer from handshake results creating ssh peer from handshake results
i> write(104) -> 104: i> write(104) -> 104:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
sending unbundle command sending unbundle command
i> write(9) -> 9: i> write(9) -> 9:
i> unbundle\n i> unbundle\n
i> write(9) -> 9: i> write(9) -> 9:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 62: o> readline() -> 62:
o> upgraded * exp-ssh-v2-0001\n (glob) o> upgraded * exp-ssh-v2-0001\n (glob)
o> readline() -> 4: o> readline() -> 4:
o> 402\n o> 412\n
o> read(402) -> 402: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch o> read(412) -> 412: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
o> read(1) -> 1: o> read(1) -> 1:
o> \n o> \n
sending unbundle command sending unbundle command
i> write(9) -> 9: i> write(9) -> 9:
i> unbundle\n i> unbundle\n
i> write(9) -> 9: i> write(9) -> 9:
i> heads 10\n i> heads 10\n
i> write(10) -> 10: 666f726365 i> write(10) -> 10: 666f726365
creating ssh peer from handshake results creating ssh peer from handshake results
i> write(104) -> 104: i> write(104) -> 104:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
sending unbundle command sending unbundle command
i> write(9) -> 9: i> write(9) -> 9:
i> unbundle\n i> unbundle\n
i> write(9) -> 9: i> write(9) -> 9:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 62: o> readline() -> 62:
o> upgraded * exp-ssh-v2-0001\n (glob) o> upgraded * exp-ssh-v2-0001\n (glob)
o> readline() -> 4: o> readline() -> 4:
o> 402\n o> 412\n
o> read(402) -> 402: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch o> read(412) -> 412: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
o> read(1) -> 1: o> read(1) -> 1:
o> \n o> \n
sending unbundle command sending unbundle command
i> write(9) -> 9: i> write(9) -> 9:
i> unbundle\n i> unbundle\n
i> write(9) -> 9: i> write(9) -> 9:
i> heads 10\n i> heads 10\n
i> write(10) -> 10: 666f726365 i> write(10) -> 10: 666f726365
creating ssh peer from handshake results creating ssh peer from handshake results
i> write(104) -> 104: i> write(104) -> 104:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
sending unbundle command sending unbundle command
i> write(9) -> 9: i> write(9) -> 9:
i> unbundle\n i> unbundle\n
i> write(9) -> 9: i> write(9) -> 9:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 62: o> readline() -> 62:
o> upgraded * exp-ssh-v2-0001\n (glob) o> upgraded * exp-ssh-v2-0001\n (glob)
o> readline() -> 4: o> readline() -> 4:
o> 402\n o> 412\n
o> read(402) -> 402: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch o> read(412) -> 412: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
o> read(1) -> 1: o> read(1) -> 1:
o> \n o> \n
sending unbundle command sending unbundle command
i> write(9) -> 9: i> write(9) -> 9:
i> unbundle\n i> unbundle\n
i> write(9) -> 9: i> write(9) -> 9:
i> heads 10\n i> heads 10\n
i> write(10) -> 10: 666f726365 i> write(10) -> 10: 666f726365
creating ssh peer from handshake results creating ssh peer from handshake results
i> write(104) -> 104: i> write(104) -> 104:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
sending unbundle command sending unbundle command
i> write(9) -> 9: i> write(9) -> 9:
i> unbundle\n i> unbundle\n
i> write(9) -> 9: i> write(9) -> 9:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 62: o> readline() -> 62:
o> upgraded * exp-ssh-v2-0001\n (glob) o> upgraded * exp-ssh-v2-0001\n (glob)
o> readline() -> 4: o> readline() -> 4:
o> 402\n o> 412\n
o> read(402) -> 402: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch o> read(412) -> 412: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
o> read(1) -> 1: o> read(1) -> 1:
o> \n o> \n
sending unbundle command sending unbundle command
i> write(9) -> 9: i> write(9) -> 9:
i> unbundle\n i> unbundle\n
i> write(9) -> 9: i> write(9) -> 9:
i> heads 10\n i> heads 10\n
i> write(10) -> 10: 666f726365 i> write(10) -> 10: 666f726365
creating ssh peer from handshake results creating ssh peer from handshake results
i> write(104) -> 104: i> write(104) -> 104:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
sending unbundle command sending unbundle command
i> write(9) -> 9: i> write(9) -> 9:
i> unbundle\n i> unbundle\n
i> write(9) -> 9: i> write(9) -> 9:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 62: o> readline() -> 62:
o> upgraded * exp-ssh-v2-0001\n (glob) o> upgraded * exp-ssh-v2-0001\n (glob)
o> readline() -> 4: o> readline() -> 4:
o> 402\n o> 412\n
o> read(402) -> 402: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch o> read(412) -> 412: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
o> read(1) -> 1: o> read(1) -> 1:
o> \n o> \n
sending unbundle command sending unbundle command
i> write(9) -> 9: i> write(9) -> 9:
i> unbundle\n i> unbundle\n
i> write(9) -> 9: i> write(9) -> 9:
i> heads 10\n i> heads 10\n
i> write(10) -> 10: 666f726365 i> write(10) -> 10: 666f726365

tests/test-ssh-proto.t

$ 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: 403 remote: 413
remote: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch remote: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
remote: 1 remote: 1
devel-peer-request: protocaps
devel-peer-request: caps: * bytes (glob)
sending protocaps command
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 debugwireproto --localssh --peer raw << EOF $ hg -R server debugwireproto --localssh --peer raw << EOF
> raw > raw
> hello\n > hello\n
> readline > readline
> readline > readline
> EOF > EOF
using raw connection to peer using raw connection to peer
i> write(6) -> 6: i> write(6) -> 6:
i> hello\n i> hello\n
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\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
403 413
capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
I/O logging works I/O logging works
$ hg debugserve --sshstdio --logiofd 1 << EOF $ hg debugserve --sshstdio --logiofd 1 << EOF
> hello > hello
> EOF > EOF
o> write(4) -> 4: o> write(4) -> 4:
o> 403\n o> 413\n
o> write(403) -> 403: o> write(413) -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
403 413
capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
o> flush() -> None o> flush() -> None
$ hg debugserve --sshstdio --logiofile $TESTTMP/io << EOF $ hg debugserve --sshstdio --logiofile $TESTTMP/io << EOF
> hello > hello
> EOF > EOF
403 413
capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
$ cat $TESTTMP/io $ cat $TESTTMP/io
o> write(4) -> 4: o> write(4) -> 4:
o> 403\n o> 413\n
o> write(403) -> 403: o> write(413) -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
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 debugwireproto --localssh --peer raw << EOF $ hg -R server debugwireproto --localssh --peer raw << EOF
> raw > raw
> hello\n > hello\n
> readline > readline
> readline > readline
> raw > raw
> between\n > between\n
> pairs 81\n > pairs 81\n
> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
> readline > readline
> readline > readline
> EOF > EOF
using raw connection to peer using raw connection to peer
i> write(6) -> 6: i> write(6) -> 6:
i> hello\n i> hello\n
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
i> write(98) -> 98: i> write(98) -> 98:
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
remote: banner: line 2 remote: banner: line 2
remote: banner: line 3 remote: banner: line 3
remote: banner: line 4 remote: banner: line 4
remote: banner: line 5 remote: banner: line 5
remote: banner: line 6 remote: banner: line 6
remote: banner: line 7 remote: banner: line 7
remote: banner: line 8 remote: banner: line 8
remote: banner: line 9 remote: banner: line 9
remote: 403 remote: 413
remote: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch remote: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
remote: 1 remote: 1
devel-peer-request: protocaps
devel-peer-request: caps: * bytes (glob)
sending protocaps command
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 debugwireproto --localssh --peer raw << EOF $ SSHSERVERMODE=banner hg -R server debugwireproto --localssh --peer raw << EOF
> raw > raw
o> banner: line 6\n o> banner: line 6\n
o> readline() -> 15: o> readline() -> 15:
o> banner: line 7\n o> banner: line 7\n
o> readline() -> 15: o> readline() -> 15:
o> banner: line 8\n o> banner: line 8\n
o> readline() -> 15: o> readline() -> 15:
o> banner: line 9\n o> banner: line 9\n
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
i> write(98) -> 98: i> write(98) -> 98:
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
using raw connection to peer using raw connection to peer
i> write(10) -> 10: i> write(10) -> 10:
i> pre-hello\n i> pre-hello\n
o> readline() -> 2: o> readline() -> 2:
o> 0\n o> 0\n
i> write(6) -> 6: i> write(6) -> 6:
i> hello\n i> hello\n
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
i> write(98) -> 98: i> write(98) -> 98:
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
o> readline() -> 2: o> readline() -> 2:
o> 1\n 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: 403 remote: 413
remote: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch remote: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
remote: 1 remote: 1
devel-peer-request: protocaps
devel-peer-request: caps: * bytes (glob)
sending protocaps command
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 debugwireproto --localssh --peer raw << EOF $ hg -R server debugwireproto --localssh --peer raw << EOF
> raw > raw
o> 0\n o> 0\n
i> write(9) -> 9: i> write(9) -> 9:
i> unknown3\n i> unknown3\n
o> readline() -> 2: o> readline() -> 2:
o> 0\n o> 0\n
i> write(6) -> 6: i> write(6) -> 6:
i> hello\n i> hello\n
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
i> write(98) -> 98: i> write(98) -> 98:
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n 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: 403 remote: 413
remote: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch remote: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
remote: 1 remote: 1
devel-peer-request: protocaps
devel-peer-request: caps: * bytes (glob)
sending protocaps command
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
$ cd server $ cd server
o> 0\n o> 0\n
o> readline() -> 2: o> readline() -> 2:
o> 0\n o> 0\n
o> readline() -> 2: o> readline() -> 2:
o> 0\n o> 0\n
i> write(6) -> 6: i> write(6) -> 6:
i> hello\n i> hello\n
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
i> write(98) -> 98: i> write(98) -> 98:
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
o> 0\n o> 0\n
o> readline() -> 2: o> readline() -> 2:
o> 0\n o> 0\n
o> readline() -> 2: o> readline() -> 2:
o> 0\n o> 0\n
i> write(6) -> 6: i> write(6) -> 6:
i> hello\n i> hello\n
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
i> write(98) -> 98: i> write(98) -> 98:
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
o> 0\n o> 0\n
o> readline() -> 2: o> readline() -> 2:
o> 0\n o> 0\n
o> readline() -> 2: o> readline() -> 2:
o> 0\n o> 0\n
i> write(6) -> 6: i> write(6) -> 6:
i> hello\n i> hello\n
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
i> write(98) -> 98: i> write(98) -> 98:
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
o> 0\n o> 0\n
o> readline() -> 2: o> readline() -> 2:
o> 0\n o> 0\n
o> readline() -> 2: o> readline() -> 2:
o> 0\n o> 0\n
i> write(6) -> 6: i> write(6) -> 6:
i> hello\n i> hello\n
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
Incomplete dictionary send Incomplete dictionary send
$ hg debugwireproto --localssh --peer raw << EOF $ hg debugwireproto --localssh --peer raw << EOF
> raw > raw
> unknown\n > unknown\n
> dict 3\n > dict 3\n
> key1 3\n > key1 3\n
using raw connection to peer using raw connection to peer
i> write(18) -> 18: i> write(18) -> 18:
i> unknown withspace\n i> unknown withspace\n
o> readline() -> 2: o> readline() -> 2:
o> 0\n o> 0\n
i> write(6) -> 6: i> write(6) -> 6:
i> hello\n i> hello\n
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
i> write(98) -> 98: i> write(98) -> 98:
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
using raw connection to peer using raw connection to peer
i> write(29) -> 29: i> write(29) -> 29:
i> unknown with multiple spaces\n i> unknown with multiple spaces\n
o> readline() -> 2: o> readline() -> 2:
o> 0\n o> 0\n
i> write(6) -> 6: i> write(6) -> 6:
i> hello\n i> hello\n
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
i> write(98) -> 98: i> write(98) -> 98:
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
$ hg debugwireproto --localssh --peer raw << EOF $ hg debugwireproto --localssh --peer raw << EOF
o> 0\n o> 0\n
o> readline() -> 2: o> readline() -> 2:
o> 0\n o> 0\n
o> readline() -> 2: o> readline() -> 2:
o> 0\n o> 0\n
i> write(6) -> 6: i> write(6) -> 6:
i> hello\n i> hello\n
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
i> write(98) -> 98: i> write(98) -> 98:
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000unknown > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000unknown
> readline > readline
> readline > readline
> EOF > EOF
using raw connection to peer using raw connection to peer
i> write(6) -> 6: i> write(6) -> 6:
i> hello\n i> hello\n
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
i> write(105) -> 105: i> write(105) -> 105:
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000unknown i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000unknown
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
> EOF > EOF
using raw connection to peer using raw connection to peer
i> write(104) -> 104: i> write(104) -> 104:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
i> write(31) -> 31: i> write(31) -> 31:
i> unknown\n i> unknown\n
i> foo 5\n i> foo 5\n
i> \n i> \n
i> write(104) -> 104: i> write(104) -> 104:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
o> readline() -> 41: o> readline() -> 41:
o> 68986213bd4485ea51533535e3fc9e78007a711f\n o> 68986213bd4485ea51533535e3fc9e78007a711f\n
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
And a variation that doesn't send the between command And a variation that doesn't send the between command
$ hg debugwireproto --localssh --peer raw << EOF $ hg debugwireproto --localssh --peer raw << EOF
> raw > raw
> heads\n > heads\n
> readline > readline
> raw > raw
> hello\n > hello\n
> readline > readline
> readline > readline
> EOF > EOF
using raw connection to peer using raw connection to peer
i> write(6) -> 6: i> write(6) -> 6:
i> heads\n i> heads\n
o> readline() -> 3: o> readline() -> 3:
o> 41\n o> 41\n
i> write(6) -> 6: i> write(6) -> 6:
i> hello\n i> hello\n
o> readline() -> 41: o> readline() -> 41:
o> 68986213bd4485ea51533535e3fc9e78007a711f\n o> 68986213bd4485ea51533535e3fc9e78007a711f\n
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\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 debugwireproto --localssh --peer raw << EOF $ hg debugwireproto --localssh --peer raw << EOF
> raw > raw
> upgrade 2e82ab3f-9ce3-4b4e-8f8c-6fd1c0e9e23a proto=irrelevant1%2Cirrelevant2\n > upgrade 2e82ab3f-9ce3-4b4e-8f8c-6fd1c0e9e23a proto=irrelevant1%2Cirrelevant2\n
> readline > readline
> raw > raw
o> readline() -> 2: o> readline() -> 2:
o> 0\n o> 0\n
i> write(104) -> 104: i> write(104) -> 104:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
$ cd .. $ 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
devel-peer-request: pairs: 81 bytes devel-peer-request: pairs: 81 bytes
sending between command sending between command
remote: 0 remote: 0
remote: 403 remote: 413
remote: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch remote: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
remote: 1 remote: 1
devel-peer-request: protocaps
devel-peer-request: caps: * bytes (glob)
sending protocaps command
url: ssh://user@dummy/server url: ssh://user@dummy/server
local: no local: no
pushable: yes pushable: yes
Enable version 2 support on server. We need to do this in hgrc because we can't Enable version 2 support on server. We need to do this in hgrc because we can't
use --config with `hg serve --stdio`. use --config with `hg serve --stdio`.
$ cat >> server/.hg/hgrc << EOF $ cat >> server/.hg/hgrc << EOF
i> upgrade this-is-some-token proto=exp-ssh-v2-0001\n i> upgrade this-is-some-token proto=exp-ssh-v2-0001\n
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
o> readline() -> 44: o> readline() -> 44:
o> upgraded this-is-some-token exp-ssh-v2-0001\n o> upgraded this-is-some-token exp-ssh-v2-0001\n
o> readline() -> 4: o> readline() -> 4:
o> 402\n o> 412\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
$ cd .. $ 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
devel-peer-request: pairs: 81 bytes devel-peer-request: pairs: 81 bytes
sending between command sending between command
protocol upgraded to exp-ssh-v2-0001 protocol upgraded to exp-ssh-v2-0001
remote: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch remote: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
devel-peer-request: protocaps
devel-peer-request: caps: * bytes (glob)
sending protocaps command
url: ssh://user@dummy/server url: ssh://user@dummy/server
local: no local: no
pushable: yes pushable: yes
Verify the peer has capabilities Verify the peer has capabilities
$ hg --config experimental.sshpeer.advertise-v2=true --debug debugcapabilities ssh://user@dummy/server $ hg --config experimental.sshpeer.advertise-v2=true --debug debugcapabilities 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
devel-peer-request: pairs: 81 bytes devel-peer-request: pairs: 81 bytes
sending between command sending between command
protocol upgraded to exp-ssh-v2-0001 protocol upgraded to exp-ssh-v2-0001
remote: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch remote: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
devel-peer-request: protocaps
devel-peer-request: caps: * bytes (glob)
sending protocaps command
Main capabilities: Main capabilities:
batch batch
branchmap branchmap
$USUAL_BUNDLE2_CAPS_SERVER$ $USUAL_BUNDLE2_CAPS_SERVER$
changegroupsubset changegroupsubset
getbundle getbundle
known known
lookup lookup
protocaps
pushkey pushkey
streamreqs=generaldelta,revlogv1 streamreqs=generaldelta,revlogv1
unbundle=HG10GZ,HG10BZ,HG10UN unbundle=HG10GZ,HG10BZ,HG10UN
unbundlehash unbundlehash
Bundle2 capabilities: Bundle2 capabilities:
HG20 HG20
bookmarks bookmarks
changegroup changegroup
i> upgrade this-is-some-token proto=exp-ssh-v2-0001\n i> upgrade this-is-some-token proto=exp-ssh-v2-0001\n
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
o> readline() -> 44: o> readline() -> 44:
o> upgraded this-is-some-token exp-ssh-v2-0001\n o> upgraded this-is-some-token exp-ssh-v2-0001\n
o> readline() -> 4: o> readline() -> 4:
o> 402\n o> 412\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
i> write(6) -> 6: i> write(6) -> 6:
i> hello\n i> hello\n
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 403\n
o> readline() -> 403: o> readline() -> 403:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n
Multiple upgrades is not allowed Multiple upgrades is not allowed
i> upgrade this-is-some-token proto=exp-ssh-v2-0001\n i> upgrade this-is-some-token proto=exp-ssh-v2-0001\n
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
o> readline() -> 44: o> readline() -> 44:
o> upgraded this-is-some-token exp-ssh-v2-0001\n o> upgraded this-is-some-token exp-ssh-v2-0001\n
o> readline() -> 4: o> readline() -> 4:
o> 402\n o> 412\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
i> write(45) -> 45: i> write(45) -> 45:
i> upgrade another-token proto=irrelevant\n i> upgrade another-token proto=irrelevant\n
i> hello\n i> hello\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
o> read(-1) -> 0: o> read(-1) -> 0:
e> read(-1) -> 42: e> read(-1) -> 42:
e> cannot upgrade protocols multiple times\n e> cannot upgrade protocols multiple times\n
using raw connection to peer using raw connection to peer
i> write(51) -> 51: i> write(51) -> 51:
i> upgrade this-is-some-token proto=unknown1,unknown2\n i> upgrade this-is-some-token proto=unknown1,unknown2\n
o> readline() -> 2: o> readline() -> 2:
o> 0\n o> 0\n
i> write(6) -> 6: i> write(6) -> 6:
i> hello\n i> hello\n
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
i> write(98) -> 98: i> write(98) -> 98:
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
creating ssh peer from handshake results creating ssh peer from handshake results
i> write(104) -> 104: i> write(104) -> 104:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
sending listkeys command sending listkeys command
i> write(9) -> 9: i> write(9) -> 9:
i> listkeys\n i> listkeys\n
i> write(13) -> 13: i> write(13) -> 13:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 62: o> readline() -> 62:
o> upgraded * exp-ssh-v2-0001\n (glob) o> upgraded * exp-ssh-v2-0001\n (glob)
o> readline() -> 4: o> readline() -> 4:
o> 402\n o> 412\n
o> read(402) -> 402: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch o> read(412) -> 412: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
o> read(1) -> 1: o> read(1) -> 1:
o> \n o> \n
sending listkeys command sending listkeys command
i> write(9) -> 9: i> write(9) -> 9:
i> listkeys\n i> listkeys\n
i> write(13) -> 13: i> write(13) -> 13:
i> namespace 10\n i> namespace 10\n
i> write(10) -> 10: namespaces i> write(10) -> 10: namespaces
creating ssh peer from handshake results creating ssh peer from handshake results
i> write(104) -> 104: i> write(104) -> 104:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
sending listkeys command sending listkeys command
i> write(9) -> 9: i> write(9) -> 9:
i> listkeys\n i> listkeys\n
i> write(12) -> 12: i> write(12) -> 12:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 62: o> readline() -> 62:
o> upgraded * exp-ssh-v2-0001\n (glob) o> upgraded * exp-ssh-v2-0001\n (glob)
o> readline() -> 4: o> readline() -> 4:
o> 402\n o> 412\n
o> read(402) -> 402: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch o> read(412) -> 412: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
o> read(1) -> 1: o> read(1) -> 1:
o> \n o> \n
sending listkeys command sending listkeys command
i> write(9) -> 9: i> write(9) -> 9:
i> listkeys\n i> listkeys\n
i> write(12) -> 12: i> write(12) -> 12:
i> namespace 9\n i> namespace 9\n
i> write(9) -> 9: bookmarks i> write(9) -> 9: bookmarks
creating ssh peer from handshake results creating ssh peer from handshake results
i> write(104) -> 104: i> write(104) -> 104:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
sending listkeys command sending listkeys command
i> write(9) -> 9: i> write(9) -> 9:
i> listkeys\n i> listkeys\n
i> write(12) -> 12: i> write(12) -> 12:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 62: o> readline() -> 62:
o> upgraded * exp-ssh-v2-0001\n (glob) o> upgraded * exp-ssh-v2-0001\n (glob)
o> readline() -> 4: o> readline() -> 4:
o> 402\n o> 412\n
o> read(402) -> 402: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch o> read(412) -> 412: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
o> read(1) -> 1: o> read(1) -> 1:
o> \n o> \n
sending listkeys command sending listkeys command
i> write(9) -> 9: i> write(9) -> 9:
i> listkeys\n i> listkeys\n
i> write(12) -> 12: i> write(12) -> 12:
i> namespace 9\n i> namespace 9\n
i> write(9) -> 9: bookmarks i> write(9) -> 9: bookmarks
creating ssh peer from handshake results creating ssh peer from handshake results
i> write(104) -> 104: i> write(104) -> 104:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
sending listkeys command sending listkeys command
i> write(9) -> 9: i> write(9) -> 9:
i> listkeys\n i> listkeys\n
i> write(12) -> 12: i> write(12) -> 12:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 62: o> readline() -> 62:
o> upgraded * exp-ssh-v2-0001\n (glob) o> upgraded * exp-ssh-v2-0001\n (glob)
o> readline() -> 4: o> readline() -> 4:
o> 402\n o> 412\n
o> read(402) -> 402: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch o> read(412) -> 412: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
o> read(1) -> 1: o> read(1) -> 1:
o> \n o> \n
sending listkeys command sending listkeys command
i> write(9) -> 9: i> write(9) -> 9:
i> listkeys\n i> listkeys\n
i> write(12) -> 12: i> write(12) -> 12:
i> namespace 9\n i> namespace 9\n
i> write(9) -> 9: bookmarks i> write(9) -> 9: bookmarks
creating ssh peer from handshake results creating ssh peer from handshake results
i> write(104) -> 104: i> write(104) -> 104:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
sending pushkey command sending pushkey command
i> write(8) -> 8: i> write(8) -> 8:
i> pushkey\n i> pushkey\n
i> write(6) -> 6: i> write(6) -> 6:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 62: o> readline() -> 62:
o> upgraded * exp-ssh-v2-0001\n (glob) o> upgraded * exp-ssh-v2-0001\n (glob)
o> readline() -> 4: o> readline() -> 4:
o> 402\n o> 412\n
o> read(402) -> 402: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch o> read(412) -> 412: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
o> read(1) -> 1: o> read(1) -> 1:
o> \n o> \n
sending pushkey command sending pushkey command
i> write(8) -> 8: i> write(8) -> 8:
i> pushkey\n i> pushkey\n
i> write(6) -> 6: i> write(6) -> 6:
i> key 6\n i> key 6\n
i> write(6) -> 6: remote i> write(6) -> 6: remote
creating ssh peer from handshake results creating ssh peer from handshake results
i> write(104) -> 104: i> write(104) -> 104:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
sending listkeys command sending listkeys command
i> write(9) -> 9: i> write(9) -> 9:
i> listkeys\n i> listkeys\n
i> write(12) -> 12: i> write(12) -> 12:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 62: o> readline() -> 62:
o> upgraded * exp-ssh-v2-0001\n (glob) o> upgraded * exp-ssh-v2-0001\n (glob)
o> readline() -> 4: o> readline() -> 4:
o> 402\n o> 412\n
o> read(402) -> 402: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch o> read(412) -> 412: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
o> read(1) -> 1: o> read(1) -> 1:
o> \n o> \n
sending listkeys command sending listkeys command
i> write(9) -> 9: i> write(9) -> 9:
i> listkeys\n i> listkeys\n
i> write(12) -> 12: i> write(12) -> 12:
i> namespace 6\n i> namespace 6\n
i> write(6) -> 6: phases i> write(6) -> 6: phases
creating ssh peer from handshake results creating ssh peer from handshake results
i> write(104) -> 104: i> write(104) -> 104:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
sending listkeys command sending listkeys command
i> write(9) -> 9: i> write(9) -> 9:
i> listkeys\n i> listkeys\n
i> write(12) -> 12: i> write(12) -> 12:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 62: o> readline() -> 62:
o> upgraded * exp-ssh-v2-0001\n (glob) o> upgraded * exp-ssh-v2-0001\n (glob)
o> readline() -> 4: o> readline() -> 4:
o> 402\n o> 412\n
o> read(402) -> 402: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch o> read(412) -> 412: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
o> read(1) -> 1: o> read(1) -> 1:
o> \n o> \n
sending listkeys command sending listkeys command
i> write(9) -> 9: i> write(9) -> 9:
i> listkeys\n i> listkeys\n
i> write(12) -> 12: i> write(12) -> 12:
i> namespace 6\n i> namespace 6\n
i> write(6) -> 6: phases i> write(6) -> 6: phases
creating ssh peer from handshake results creating ssh peer from handshake results
i> write(104) -> 104: i> write(104) -> 104:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
sending listkeys command sending listkeys command
i> write(9) -> 9: i> write(9) -> 9:
i> listkeys\n i> listkeys\n
i> write(12) -> 12: i> write(12) -> 12:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 62: o> readline() -> 62:
o> upgraded * exp-ssh-v2-0001\n (glob) o> upgraded * exp-ssh-v2-0001\n (glob)
o> readline() -> 4: o> readline() -> 4:
o> 402\n o> 412\n
o> read(402) -> 402: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch o> read(412) -> 412: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
o> read(1) -> 1: o> read(1) -> 1:
o> \n o> \n
sending listkeys command sending listkeys command
i> write(9) -> 9: i> write(9) -> 9:
i> listkeys\n i> listkeys\n
i> write(12) -> 12: i> write(12) -> 12:
i> namespace 6\n i> namespace 6\n
i> write(6) -> 6: phases i> write(6) -> 6: phases
creating ssh peer from handshake results creating ssh peer from handshake results
i> write(104) -> 104: i> write(104) -> 104:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
sending listkeys command sending listkeys command
i> write(9) -> 9: i> write(9) -> 9:
i> listkeys\n i> listkeys\n
i> write(12) -> 12: i> write(12) -> 12:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 62: o> readline() -> 62:
o> upgraded * exp-ssh-v2-0001\n (glob) o> upgraded * exp-ssh-v2-0001\n (glob)
o> readline() -> 4: o> readline() -> 4:
o> 402\n o> 412\n
o> read(402) -> 402: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch o> read(412) -> 412: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
o> read(1) -> 1: o> read(1) -> 1:
o> \n o> \n
sending listkeys command sending listkeys command
i> write(9) -> 9: i> write(9) -> 9:
i> listkeys\n i> listkeys\n
i> write(12) -> 12: i> write(12) -> 12:
i> namespace 6\n i> namespace 6\n
i> write(6) -> 6: phases i> write(6) -> 6: phases
creating ssh peer from handshake results creating ssh peer from handshake results
i> write(104) -> 104: i> write(104) -> 104:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
sending pushkey command sending pushkey command
i> write(8) -> 8: i> write(8) -> 8:
i> pushkey\n i> pushkey\n
i> write(7) -> 7: i> write(7) -> 7:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 62: o> readline() -> 62:
o> upgraded * exp-ssh-v2-0001\n (glob) o> upgraded * exp-ssh-v2-0001\n (glob)
o> readline() -> 4: o> readline() -> 4:
o> 402\n o> 412\n
o> read(402) -> 402: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch o> read(412) -> 412: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
o> read(1) -> 1: o> read(1) -> 1:
o> \n o> \n
sending pushkey command sending pushkey command
i> write(8) -> 8: i> write(8) -> 8:
i> pushkey\n i> pushkey\n
i> write(7) -> 7: i> write(7) -> 7:
i> key 40\n i> key 40\n
i> write(40) -> 40: 7127240a084fd9dc86fe8d1f98e26229161ec82b i> write(40) -> 40: 7127240a084fd9dc86fe8d1f98e26229161ec82b
creating ssh peer from handshake results creating ssh peer from handshake results
i> write(104) -> 104: i> write(104) -> 104:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 4: o> readline() -> 4:
o> 403\n o> 413\n
o> readline() -> 403: o> readline() -> 413:
o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch\n o> capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch\n
o> readline() -> 2: o> readline() -> 2:
o> 1\n o> 1\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
sending batch with 3 sub-commands sending batch with 3 sub-commands
i> write(6) -> 6: i> write(6) -> 6:
i> batch\n i> batch\n
i> write(4) -> 4: i> write(4) -> 4:
i> hello\n i> hello\n
i> between\n i> between\n
i> pairs 81\n i> pairs 81\n
i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000 i> 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
i> flush() -> None i> flush() -> None
o> readline() -> 62: o> readline() -> 62:
o> upgraded * exp-ssh-v2-0001\n (glob) o> upgraded * exp-ssh-v2-0001\n (glob)
o> readline() -> 4: o> readline() -> 4:
o> 402\n o> 412\n
o> read(402) -> 402: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch o> read(412) -> 412: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
o> read(1) -> 1: o> read(1) -> 1:
o> \n o> \n
sending batch with 3 sub-commands sending batch with 3 sub-commands
i> write(6) -> 6: i> write(6) -> 6:
i> batch\n i> batch\n
i> write(4) -> 4: i> write(4) -> 4:
i> * 0\n i> * 0\n
i> write(8) -> 8: i> write(8) -> 8:

tests/test-ssh.t

pulling from ssh://user@dummy/remote pulling from ssh://user@dummy/remote
running .* ".*/dummyssh" ['"]user@dummy['"] ('|")hg -R remote serve --stdio('|") (re) running .* ".*/dummyssh" ['"]user@dummy['"] ('|")hg -R remote serve --stdio('|") (re)
sending upgrade request: * proto=exp-ssh-v2-0001 (glob) (sshv2 !) sending upgrade request: * proto=exp-ssh-v2-0001 (glob) (sshv2 !)
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: 403 (sshv1 !) remote: 413 (sshv1 !)
protocol upgraded to exp-ssh-v2-0001 (sshv2 !) protocol upgraded to exp-ssh-v2-0001 (sshv2 !)
remote: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch remote: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN protocaps batch
remote: 1 (sshv1 !) remote: 1 (sshv1 !)
devel-peer-request: protocaps
devel-peer-request: caps: * bytes (glob)
sending protocaps command
query 1; heads query 1; heads
devel-peer-request: batched-content devel-peer-request: batched-content
devel-peer-request: - heads (0 arguments) devel-peer-request: - heads (0 arguments)
devel-peer-request: - known (1 arguments) devel-peer-request: - known (1 arguments)
devel-peer-request: batch devel-peer-request: batch
devel-peer-request: cmds: 141 bytes devel-peer-request: cmds: 141 bytes
sending batch command sending batch command
searching for changes searching for changes