This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2080

wireprotoserver: split ssh protocol handler and server
ClosedPublic

Authored by indygreg on Feb 7 2018, 7:26 PM.

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHGbf676267f64f: wireprotoserver: split ssh protocol handler and server
Summary

We want to formalize the interface for protocol handlers. Today,
server functionality (which is domain specific) is interleaved
with protocol handling functionality (which conforms to a generic
interface) in the sshserver class.

This commit splits the ssh protocol handling code out of the
sshserver class.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

indygreg created this revision.Feb 7 2018, 7:26 PM
indygreg edited the summary of this revision. (Show Details)Feb 7 2018, 11:32 PM
indygreg updated this revision to Diff 5332.
indygreg updated this revision to Diff 5343.Feb 8 2018, 12:20 AM
durin42 accepted this revision.Feb 12 2018, 4:20 PM
This revision is now accepted and ready to land.Feb 12 2018, 4:20 PM
Closed by commit rHGbf676267f64f: wireprotoserver: split ssh protocol handler and server (authored by indygreg). · Explain WhyFeb 12 2018, 4:33 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 5314

mercurial/wireprotoserver.py

req.headers.append((r'Connection', r'Close')) req.headers.append((r'Connection', r'Close'))
# TODO This response body assumes the failed command was # TODO This response body assumes the failed command was
# "unbundle." That assumption is not always valid. # "unbundle." That assumption is not always valid.
req.respond(e, HGTYPE, body='0\n%s\n' % e) req.respond(e, HGTYPE, body='0\n%s\n' % e)
return '' return ''
class sshserver(baseprotocolhandler): class sshprotocolhandler(baseprotocolhandler):
def __init__(self, ui, repo): def __init__(self, ui, fin, fout):
self._ui = ui self._ui = ui
self._repo = repo self._fin = fin
self._fin = ui.fin self._fout = fout
self._fout = ui.fout
hook.redirect(True)
ui.fout = repo.ui.fout = ui.ferr
# Prevent insertion/deletion of CRs
util.setbinary(self._fin)
util.setbinary(self._fout)
@property @property
def name(self): def name(self):
return 'ssh' return 'ssh'
def getargs(self, args): def getargs(self, args):
data = {} data = {}
keys = args.split() keys = args.split()
self._sendresponse(rsp.res) self._sendresponse(rsp.res)
def _sendooberror(self, rsp): def _sendooberror(self, rsp):
self._ui.ferr.write('%s\n-\n' % rsp.message) self._ui.ferr.write('%s\n-\n' % rsp.message)
self._ui.ferr.flush() self._ui.ferr.flush()
self._fout.write('\n') self._fout.write('\n')
self._fout.flush() self._fout.flush()
def serve_forever(self):
while self.serve_one():
pass
sys.exit(0)
_handlers = { _handlers = {
str: _sendresponse, str: _sendresponse,
wireproto.streamres: _sendstream, wireproto.streamres: _sendstream,
wireproto.streamres_legacy: _sendstream, wireproto.streamres_legacy: _sendstream,
wireproto.pushres: _sendpushresponse, wireproto.pushres: _sendpushresponse,
wireproto.pusherr: _sendpusherror, wireproto.pusherr: _sendpusherror,
wireproto.ooberror: _sendooberror, wireproto.ooberror: _sendooberror,
} }
def _client(self):
client = encoding.environ.get('SSH_CLIENT', '').split(' ', 1)[0]
return 'remote:ssh:' + client
class sshserver(object):
def __init__(self, ui, repo):
self._ui = ui
self._repo = repo
self._fin = ui.fin
self._fout = ui.fout
hook.redirect(True)
ui.fout = repo.ui.fout = ui.ferr
# Prevent insertion/deletion of CRs
util.setbinary(self._fin)
util.setbinary(self._fout)
self._proto = sshprotocolhandler(self._ui, self._fin, self._fout)
def serve_forever(self):
while self.serve_one():
pass
sys.exit(0)
def serve_one(self): def serve_one(self):
# TODO improve boundary between transport layer and protocol handler.
cmd = self._fin.readline()[:-1] cmd = self._fin.readline()[:-1]
if cmd and wireproto.commands.commandavailable(cmd, self): if cmd and wireproto.commands.commandavailable(cmd, self._proto):
rsp = wireproto.dispatch(self._repo, self, cmd) rsp = wireproto.dispatch(self._repo, self._proto, cmd)
self._handlers[rsp.__class__](self, rsp) self._proto._handlers[rsp.__class__](self._proto, rsp)
elif cmd: elif cmd:
self._sendresponse("") self._proto._sendresponse("")
return cmd != ''
def _client(self): return cmd != ''
client = encoding.environ.get('SSH_CLIENT', '').split(' ', 1)[0]
return 'remote:ssh:' + client

tests/sshprotoext.py

0.9.1. Modern clients send the ``hello`` command when connecting 0.9.1. Modern clients send the ``hello`` command when connecting
to SSH servers. This mock server tests behavior of the handshake to SSH servers. This mock server tests behavior of the handshake
when ``hello`` is not supported. when ``hello`` is not supported.
""" """
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.
self._sendresponse(b'') self._proto._sendresponse(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, b'between') rsp = wireproto.dispatch(self._repo, self._proto, b'between')
self._handlers[rsp.__class__](self, rsp) self._proto._handlers[rsp.__class__](self._proto, rsp)
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.
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) servercaps = wireproto.capabilities(self._repo, self._proto)
rsp = b'capabilities: %s' % servercaps rsp = b'capabilities: %s' % servercaps
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

['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)
_func, spec = wireproto.commands[cmd] _func, spec = wireproto.commands[cmd]
self.assertEqual(server.getargs(spec), expected) self.assertEqual(server._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):