This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2203

wireprotoserver: move SSH server operation to a standalone function
ClosedPublic

Authored by indygreg on Feb 12 2018, 7:46 PM.

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHG3b3a987bbbaa: wireprotoserver: move SSH server operation to a standalone function
rHGabd6a0e32e22: wireprotoserver: move SSH server operation to a standalone function
Summary

The server-side processing logic will soon get a bit more complicated
in order to handle protocol switches. We will use a state machine
to help make the transitions clearer.

To prepare for this, we move SSH server operation into a standalone
function. We structure it as a very simple state machine. It only
has two states for now, with one state containing the bulk of the
logic. But things will evolve shortly.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

indygreg created this revision.Feb 12 2018, 7:46 PM
durin42 accepted this revision.Feb 14 2018, 8:49 PM
durin42 added a subscriber: durin42.

LGTM, but needs rebased

This revision is now accepted and ready to land.Feb 14 2018, 8:49 PM
Closed by commit rHGabd6a0e32e22: wireprotoserver: move SSH server operation to a standalone function (authored by indygreg). · Explain WhyFeb 14 2018, 9:04 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 5572

mercurial/wireprotoserver.py

@contextlib.contextmanager @contextlib.contextmanager
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 _runsshserver(ui, repo, fin, fout):
state = 'protov1-serving'
proto = sshv1protocolhandler(ui, fin, fout)
while True:
if state == 'protov1-serving':
# Commands are issued on new lines.
request = fin.readline()[:-1]
# Empty lines signal to terminate the connection.
if not request:
state = 'shutdown'
continue
available = wireproto.commands.commandavailable(request, proto)
# This command isn't available. Send an empty response and go
# back to waiting for a new command.
if not available:
_sshv1respondbytes(fout, b'')
continue
rsp = wireproto.dispatch(repo, proto, request)
if isinstance(rsp, bytes):
_sshv1respondbytes(fout, rsp)
elif isinstance(rsp, wireprototypes.bytesresponse):
_sshv1respondbytes(fout, rsp.data)
elif isinstance(rsp, wireprototypes.streamres):
_sshv1respondstream(fout, rsp)
elif isinstance(rsp, wireprototypes.streamreslegacy):
_sshv1respondstream(fout, rsp)
elif isinstance(rsp, wireprototypes.pushres):
_sshv1respondbytes(fout, b'')
_sshv1respondbytes(fout, bytes(rsp.res))
elif isinstance(rsp, wireprototypes.pusherr):
_sshv1respondbytes(fout, rsp.res)
elif isinstance(rsp, wireprototypes.ooberror):
_sshv1respondooberror(fout, ui.ferr, rsp.message)
else:
raise error.ProgrammingError('unhandled response type from '
'wire protocol command: %s' % rsp)
elif state == 'shutdown':
break
else:
raise error.ProgrammingError('unhandled ssh server state: %s' %
state)
class sshserver(object): class sshserver(object):
def __init__(self, ui, repo): def __init__(self, ui, repo):
self._ui = ui self._ui = ui
self._repo = repo self._repo = repo
self._fin = ui.fin self._fin = ui.fin
self._fout = ui.fout self._fout = ui.fout
hook.redirect(True) hook.redirect(True)
ui.fout = repo.ui.fout = ui.ferr ui.fout = repo.ui.fout = ui.ferr
# Prevent insertion/deletion of CRs # Prevent insertion/deletion of CRs
util.setbinary(self._fin) util.setbinary(self._fin)
util.setbinary(self._fout) util.setbinary(self._fout)
self._proto = sshv1protocolhandler(self._ui, self._fin, self._fout)
def serve_forever(self): def serve_forever(self):
while self.serve_one(): _runsshserver(self._ui, self._repo, self._fin, self._fout)
pass
sys.exit(0) sys.exit(0)
def serve_one(self):
cmd = self._fin.readline()[:-1]
if cmd and wireproto.commands.commandavailable(cmd, self._proto):
rsp = wireproto.dispatch(self._repo, self._proto, cmd)
if isinstance(rsp, bytes):
_sshv1respondbytes(self._fout, rsp)
elif isinstance(rsp, wireprototypes.bytesresponse):
_sshv1respondbytes(self._fout, rsp.data)
elif isinstance(rsp, wireprototypes.streamres):
_sshv1respondstream(self._fout, rsp)
elif isinstance(rsp, wireprototypes.streamreslegacy):
_sshv1respondstream(self._fout, rsp)
elif isinstance(rsp, wireprototypes.pushres):
_sshv1respondbytes(self._fout, b'')
_sshv1respondbytes(self._fout, bytes(rsp.res))
elif isinstance(rsp, wireprototypes.pusherr):
_sshv1respondbytes(self._fout, rsp.res)
elif isinstance(rsp, wireprototypes.ooberror):
_sshv1respondooberror(self._fout, self._ui.ferr, rsp.message)
else:
raise error.ProgrammingError('unhandled response type from '
'wire protocol command: %s' % rsp)
elif cmd:
_sshv1respondbytes(self._fout, b'')
return cmd != ''

tests/sshprotoext.py

""" """
def serve_forever(self): def serve_forever(self):
l = self._fin.readline() l = self._fin.readline()
assert l == b'hello\n' assert l == b'hello\n'
# Respond to unknown commands with an empty reply. # Respond to unknown commands with an empty reply.
wireprotoserver._sshv1respondbytes(self._fout, b'') wireprotoserver._sshv1respondbytes(self._fout, b'')
l = self._fin.readline() l = self._fin.readline()
assert l == b'between\n' assert l == b'between\n'
rsp = wireproto.dispatch(self._repo, self._proto, b'between') proto = wireprotoserver.sshv1protocolhandler(self._ui, self._fin,
self._fout)
rsp = wireproto.dispatch(self._repo, proto, b'between')
wireprotoserver._sshv1respondbytes(self._fout, rsp.data) wireprotoserver._sshv1respondbytes(self._fout, rsp.data)
super(prehelloserver, self).serve_forever() super(prehelloserver, self).serve_forever()
class upgradev2server(wireprotoserver.sshserver): class upgradev2server(wireprotoserver.sshserver):
"""Tests behavior for clients that issue upgrade to version 2.""" """Tests behavior for clients that issue upgrade to version 2."""
def serve_forever(self): def serve_forever(self):
name = wireprotoserver.SSHV2 name = wireprotoserver.SSHV2
l = self._fin.readline() l = self._fin.readline()
assert l.startswith(b'upgrade ') assert l.startswith(b'upgrade ')
token, caps = l[:-1].split(b' ')[1:] token, caps = l[:-1].split(b' ')[1:]
assert caps == b'proto=%s' % name assert caps == b'proto=%s' % name
# Filter hello and between requests. # Filter hello and between requests.
l = self._fin.readline() l = self._fin.readline()
assert l == b'hello\n' assert l == b'hello\n'
l = self._fin.readline() l = self._fin.readline()
assert l == b'between\n' assert l == b'between\n'
l = self._fin.readline() l = self._fin.readline()
assert l == 'pairs 81\n' assert l == 'pairs 81\n'
self._fin.read(81) self._fin.read(81)
# Send the upgrade response. # Send the upgrade response.
proto = wireprotoserver.sshv1protocolhandler(self._ui, self._fin,
self._fout)
self._fout.write(b'upgraded %s %s\n' % (token, name)) self._fout.write(b'upgraded %s %s\n' % (token, name))
servercaps = wireproto.capabilities(self._repo, self._proto) servercaps = wireproto.capabilities(self._repo, proto)
rsp = b'capabilities: %s' % servercaps.data rsp = b'capabilities: %s' % servercaps.data
self._fout.write(b'%d\n' % len(rsp)) self._fout.write(b'%d\n' % len(rsp))
self._fout.write(rsp) self._fout.write(rsp)
self._fout.write(b'\n') self._fout.write(b'\n')
self._fout.flush() self._fout.flush()
super(upgradev2server, self).serve_forever() super(upgradev2server, self).serve_forever()

tests/test-sshserver.py

('* 0\nnodes 40\n1111111111111111111111111111111111111111\n', ('* 0\nnodes 40\n1111111111111111111111111111111111111111\n',
['1111111111111111111111111111111111111111', {}]), ['1111111111111111111111111111111111111111', {}]),
] ]
for input, expected in tests: for input, expected in tests:
self.assertparse('known', input, expected) self.assertparse('known', input, expected)
def assertparse(self, cmd, input, expected): def assertparse(self, cmd, input, expected):
server = mockserver(input) server = mockserver(input)
proto = wireprotoserver.sshv1protocolhandler(server._ui,
server._fin,
server._fout)
_func, spec = wireproto.commands[cmd] _func, spec = wireproto.commands[cmd]
self.assertEqual(server._proto.getargs(spec), expected) self.assertEqual(proto.getargs(spec), expected)
def mockserver(inbytes): def mockserver(inbytes):
ui = mockui(inbytes) ui = mockui(inbytes)
repo = mockrepo(ui) repo = mockrepo(ui)
return wireprotoserver.sshserver(ui, repo) return wireprotoserver.sshserver(ui, repo)
class mockrepo(object): class mockrepo(object):
def __init__(self, ui): def __init__(self, ui):