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.

Download Raw Diff

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

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 7 2018, 7:26 PM

Herald added a reviewer: hg-reviewers. · View Herald TranscriptFeb 7 2018, 7:26 PM

Herald added a subscriber: mercurial-devel. · View Herald Transcript

indygreg added a child revision: D2081: wireprotoserver: add context manager mechanism for redirecting stdio.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

			Path	Packages
M			mercurial/wireprotoserver.py (45 lines)
M			tests/sshprotoext.py (4 lines)
M			tests/test-sshserver.py (2 lines)

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	5314		Feb 7 2018, 7:26 PM	★	★
Diff 2	5332		Feb 7 2018, 11:32 PM	★	★
Diff 3	5343		Feb 8 2018, 12:20 AM	★	★
Diff 4	5526	rHGbf676267f64f449e8efe99b5731a33715c9b7e9f	Feb 7 2018, 11:17 PM	★	★

Status	Author	Revision
Closed	indygreg	D2094 wireprotoserver: define and use parse_qs from urllib
Closed	indygreg	D2093 tests: add tests for sending recognized command before handshake
Closed	indygreg	D2092 wireprotoserver: add version to SSH protocol names (API)
Closed	indygreg	D2089 wireproto: introduce type for raw byte responses (API)
Closed	indygreg	D2088 wireprototypes: move wire protocol response types to new module
Closed	indygreg	D2087 wireprotoserver: move responsetype() out of http handler
Closed	indygreg	D2086 wireproto: remove unused proto argument from supportedcompengines (API)
Closed	indygreg	D2085 wireprotoserver: rename getfile() to forwardpayload() (API)
Closed	indygreg	D2084 wireprotoserver: rename _client to client (API)
Closed	indygreg	D2083 wireprotoserver: remove redirect() and restore() (API)
Closed	indygreg	D2082 wireproto: use maybecapturestdio() for push responses (API)
Closed	indygreg	D2081 wireprotoserver: add context manager mechanism for redirecting stdio
Closed	indygreg	D2080 wireprotoserver: split ssh protocol handler and server

Diff 5526

mercurial/wireprotoserver.py

	fout.flush()			fout.flush()

	def _sshv1respondooberror(fout, ferr, rsp):			def _sshv1respondooberror(fout, ferr, rsp):
	ferr.write(b'%s\n-\n' % rsp)			ferr.write(b'%s\n-\n' % rsp)
	ferr.flush()			ferr.flush()
	fout.write(b'\n')			fout.write(b'\n')
	fout.flush()			fout.flush()

	class sshserver(baseprotocolhandler):			class sshv1protocolhandler(baseprotocolhandler):
	def __init__(self, ui, repo):			"""Handler for requests services via version 1 of SSH protocol."""
				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()
	count = int(self._fin.readline())			count = int(self._fin.readline())
	while count:			while count:
	fpout.write(self._fin.read(count))			fpout.write(self._fin.read(count))
	count = int(self._fin.readline())			count = int(self._fin.readline())

	def redirect(self):			def redirect(self):
	pass			pass

				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 = sshv1protocolhandler(self._ui, self._fin, self._fout)

	def serve_forever(self):			def serve_forever(self):
	while self.serve_one():			while self.serve_one():
	pass			pass
	sys.exit(0)			sys.exit(0)

	def serve_one(self):			def serve_one(self):
	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)

	if isinstance(rsp, bytes):			if isinstance(rsp, bytes):
	_sshv1respondbytes(self._fout, rsp)			_sshv1respondbytes(self._fout, rsp)
	elif isinstance(rsp, wireproto.streamres):			elif isinstance(rsp, wireproto.streamres):
	_sshv1respondstream(self._fout, rsp)			_sshv1respondstream(self._fout, rsp)
	elif isinstance(rsp, wireproto.streamres_legacy):			elif isinstance(rsp, wireproto.streamres_legacy):
	_sshv1respondstream(self._fout, rsp)			_sshv1respondstream(self._fout, rsp)
	elif isinstance(rsp, wireproto.pushres):			elif isinstance(rsp, wireproto.pushres):
	_sshv1respondbytes(self._fout, b'')			_sshv1respondbytes(self._fout, b'')
	_sshv1respondbytes(self._fout, bytes(rsp.res))			_sshv1respondbytes(self._fout, bytes(rsp.res))
	elif isinstance(rsp, wireproto.pusherr):			elif isinstance(rsp, wireproto.pusherr):
	_sshv1respondbytes(self._fout, rsp.res)			_sshv1respondbytes(self._fout, rsp.res)
	elif isinstance(rsp, wireproto.ooberror):			elif isinstance(rsp, wireproto.ooberror):
	_sshv1respondooberror(self._fout, self._ui.ferr, rsp.message)			_sshv1respondooberror(self._fout, self._ui.ferr, rsp.message)
	else:			else:
	raise error.ProgrammingError('unhandled response type from '			raise error.ProgrammingError('unhandled response type from '
	'wire protocol command: %s' % rsp)			'wire protocol command: %s' % rsp)
	elif cmd:			elif cmd:
	_sshv1respondbytes(self._fout, b'')			_sshv1respondbytes(self._fout, b'')
	return cmd != ''			return cmd != ''

	def _client(self):
	client = encoding.environ.get('SSH_CLIENT', '').split(' ', 1)[0]
	return 'remote:ssh:' + client

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, b'between')			rsp = wireproto.dispatch(self._repo, self._proto, b'between')
	wireprotoserver._sshv1respondbytes(self._fout, rsp)			wireprotoserver._sshv1respondbytes(self._fout, 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):