This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2467

sshpeer: support not reading and forwarding stderr
ClosedPublic

Authored by indygreg on Feb 26 2018, 4:16 PM.

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHG1a36ef7df70a: sshpeer: support not reading and forwarding stderr
rHG9dfedb47d000: sshpeer: support not reading and forwarding stderr
Summary

The "doublepipe" primitive as used by sshpeer will automatically read
from stderr and forward output to the local ui.

This poses problems for deterministic testing because reads may not
be consistent. For example, the server may not be done sending all
output to stderr and the client will perform different numbers of
read operations or will read from stderr and stdout at different times.

To make tests deterministic, we'll need to disable the "doublepipe"
primitive and perform stderr I/O explicitly. We add an argument to the
sshpeer constructor to disable the use of the doublepipe.

Diff Detail

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

Event Timeline

indygreg created this revision.Feb 26 2018, 4:16 PM
indygreg updated this revision to Diff 6255.Mar 1 2018, 11:30 AM
durin42 accepted this revision.Mar 1 2018, 4:39 PM
This revision is now accepted and ready to land.Mar 1 2018, 4:39 PM
Closed by commit rHG9dfedb47d000: sshpeer: support not reading and forwarding stderr (authored by indygreg). · Explain WhyMar 1 2018, 4:55 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/sshpeer.py (18 lines)

Diff 6288

mercurial/sshpeer.py

badresponse() badresponse()
# Flush any output on stderr before proceeding. # Flush any output on stderr before proceeding.
_forwardoutput(ui, stderr) _forwardoutput(ui, stderr)
return protoname, caps return protoname, caps
class sshv1peer(wireproto.wirepeer): class sshv1peer(wireproto.wirepeer):
def __init__(self, ui, url, proc, stdin, stdout, stderr, caps): def __init__(self, ui, url, proc, stdin, stdout, stderr, caps,
autoreadstderr=True):
"""Create a peer from an existing SSH connection. """Create a peer from an existing SSH connection.
``proc`` is a handle on the underlying SSH process. ``proc`` is a handle on the underlying SSH process.
``stdin``, ``stdout``, and ``stderr`` are handles on the stdio ``stdin``, ``stdout``, and ``stderr`` are handles on the stdio
pipes for that process. pipes for that process.
``caps`` is a set of capabilities supported by the remote. ``caps`` is a set of capabilities supported by the remote.
``autoreadstderr`` denotes whether to automatically read from
stderr and to forward its output.
""" """
self._url = url self._url = url
self._ui = ui self._ui = ui
# self._subprocess is unused. Keeping a handle on the process # self._subprocess is unused. Keeping a handle on the process
# holds a reference and prevents it from being garbage collected. # holds a reference and prevents it from being garbage collected.
self._subprocess = proc self._subprocess = proc
# And we hook up our "doublepipe" wrapper to allow querying # And we hook up our "doublepipe" wrapper to allow querying
# stderr any time we perform I/O. # stderr any time we perform I/O.
if autoreadstderr:
stdout = doublepipe(ui, util.bufferedinputpipe(stdout), stderr) stdout = doublepipe(ui, util.bufferedinputpipe(stdout), stderr)
stdin = doublepipe(ui, stdin, stderr) stdin = doublepipe(ui, stdin, stderr)
self._pipeo = stdin self._pipeo = stdin
self._pipei = stdout self._pipei = stdout
self._pipee = stderr self._pipee = stderr
self._caps = caps self._caps = caps
# Commands that have a "framed" response where the first line of the # Commands that have a "framed" response where the first line of the
# response contains the length of that response. # response contains the length of that response.
self._readerr() self._readerr()
class sshv2peer(sshv1peer): class sshv2peer(sshv1peer):
"""A peer that speakers version 2 of the transport protocol.""" """A peer that speakers version 2 of the transport protocol."""
# Currently version 2 is identical to version 1 post handshake. # Currently version 2 is identical to version 1 post handshake.
# And handshake is performed before the peer is instantiated. So # And handshake is performed before the peer is instantiated. So
# we need no custom code. # we need no custom code.
def makepeer(ui, path, proc, stdin, stdout, stderr): def makepeer(ui, path, proc, stdin, stdout, stderr, autoreadstderr=True):
"""Make a peer instance from existing pipes. """Make a peer instance from existing pipes.
``path`` and ``proc`` are stored on the eventual peer instance and may ``path`` and ``proc`` are stored on the eventual peer instance and may
not be used for anything meaningful. not be used for anything meaningful.
``stdin``, ``stdout``, and ``stderr`` are the pipes connected to the ``stdin``, ``stdout``, and ``stderr`` are the pipes connected to the
SSH server's stdio handles. SSH server's stdio handles.
This function is factored out to allow creating peers that don't This function is factored out to allow creating peers that don't
actually spawn a new process. It is useful for starting SSH protocol actually spawn a new process. It is useful for starting SSH protocol
servers and clients via non-standard means, which can be useful for servers and clients via non-standard means, which can be useful for
testing. testing.
""" """
try: try:
protoname, caps = _performhandshake(ui, stdin, stdout, stderr) protoname, caps = _performhandshake(ui, stdin, stdout, stderr)
except Exception: except Exception:
_cleanuppipes(ui, stdout, stdin, stderr) _cleanuppipes(ui, stdout, stdin, stderr)
raise raise
if protoname == wireprotoserver.SSHV1: if protoname == wireprotoserver.SSHV1:
return sshv1peer(ui, path, proc, stdin, stdout, stderr, caps) return sshv1peer(ui, path, proc, stdin, stdout, stderr, caps,
autoreadstderr=autoreadstderr)
elif protoname == wireprotoserver.SSHV2: elif protoname == wireprotoserver.SSHV2:
return sshv2peer(ui, path, proc, stdin, stdout, stderr, caps) return sshv2peer(ui, path, proc, stdin, stdout, stderr, caps,
autoreadstderr=autoreadstderr)
else: else:
_cleanuppipes(ui, stdout, stdin, stderr) _cleanuppipes(ui, stdout, stdin, stderr)
raise error.RepoError(_('unknown version of SSH protocol: %s') % raise error.RepoError(_('unknown version of SSH protocol: %s') %
protoname) protoname)
def instance(ui, path, create): def instance(ui, path, create):
"""Create an SSH peer. """Create an SSH peer.