This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2461

wireprotoserver: ability to run an SSH server until an event is set
ClosedPublic

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

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGe7411fb7ba7f: wireprotoserver: ability to run an SSH server until an event is set
Summary

It seems useful to be able to start an SSH protocol server that
won't run forever and won't call sys.exit() when it stops. This
could be used to facilitate intra-process testing of the SSH
protocol, for example.

We teach the server function to loop until a threading.Event is set
and invent a new API to run the server until an event is set. It also
won't sys.exit() afterwards.

There aren't many callers of serve_forever(). So we could refactor
them relatively easily. But I was lazy.

threading.Event might be a bit heavyweight. An alternative would be
a list whose only elements is changed. We can't use a simple scalar
value like a bool or int because those types are immutable. Events
are what you use in systems programming for this use case, so the
use of threading.Event seems justified.

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.

Revision Contents
Changeset List

PathPackages
Mmercurial/wireprotoserver.py (11 lines)

Diff 6278

mercurial/wireprotoserver.py

# Copyright 21 May 2005 - (c) 2005 Jake Edge <jake@edge2.net> # Copyright 21 May 2005 - (c) 2005 Jake Edge <jake@edge2.net>
# Copyright 2005-2007 Matt Mackall <mpm@selenic.com> # Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
import contextlib import contextlib
import struct import struct
import sys import sys
import threading
from .i18n import _ from .i18n import _
from . import ( from . import (
encoding, encoding,
error, error,
hook, hook,
pycompat, pycompat,
util, util,
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
class sshv2protocolhandler(sshv1protocolhandler): class sshv2protocolhandler(sshv1protocolhandler):
"""Protocol handler for version 2 of the SSH protocol.""" """Protocol handler for version 2 of the SSH protocol."""
def _runsshserver(ui, repo, fin, fout): def _runsshserver(ui, repo, fin, fout, ev):
# This function operates like a state machine of sorts. The following # This function operates like a state machine of sorts. The following
# states are defined: # states are defined:
# #
# protov1-serving # protov1-serving
# Server is in protocol version 1 serving mode. Commands arrive on # Server is in protocol version 1 serving mode. Commands arrive on
# new lines. These commands are processed in this state, one command # new lines. These commands are processed in this state, one command
# after the other. # after the other.
# #
# protov2-serving -> protov1-serving # protov2-serving -> protov1-serving
# Ths happens by default since protocol version 2 is the same as # Ths happens by default since protocol version 2 is the same as
# version 1 except for the handshake. # version 1 except for the handshake.
state = 'protov1-serving' state = 'protov1-serving'
proto = sshv1protocolhandler(ui, fin, fout) proto = sshv1protocolhandler(ui, fin, fout)
protoswitched = False protoswitched = False
while True: while not ev.is_set():
if state == 'protov1-serving': if state == 'protov1-serving':
# Commands are issued on new lines. # Commands are issued on new lines.
request = fin.readline()[:-1] request = fin.readline()[:-1]
# Empty lines signal to terminate the connection. # Empty lines signal to terminate the connection.
if not request: if not request:
state = 'shutdown' state = 'shutdown'
continue continue
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)
def serve_forever(self): def serve_forever(self):
_runsshserver(self._ui, self._repo, self._fin, self._fout) self.serveuntil(threading.Event())
sys.exit(0) sys.exit(0)
def serveuntil(self, ev):
"""Serve until a threading.Event is set."""
_runsshserver(self._ui, self._repo, self._fin, self._fout, ev)