def server_running(server: BaseWSGIServer) -> Iterator[None]:
"""Context manager for running the provided server in a separate thread."""
thread = threading.Thread(target=server.serve_forever)
thread.daemon = True
with blocked_signals():
thread.start()
try:
yield
finally:
server.shutdown()
thread.join()
class WsgiServer(_BaseServer):
def __init__(self, loop, timeout=15, **kwargs):
super().__init__(loop, **kwargs)
self.loop = loop
self.timeout = timeout
@Request.application
def app(request):
fut = asyncio.run_coroutine_threadsafe(
self._handle(_WSGIRequest(request)), self.loop)
fields = ('response', 'status', 'headers', 'mimetype',
'content_type', 'direct_passthrough')
try:
args, kwargs = fut.result()
kw = dict(zip(fields, args))
if kwargs.get('text'):
kwargs['response'] = kwargs.pop('text')
return Response(**kw, **kwargs)
except TimeoutError:
return Response(status=502)
except Exception:
return Response(status=500)
self.wsgi_app = app
self.server = None
self._requests = []
async def start_server(self, port, **kwargs):
await super().start_server(**kwargs)
self.server = BaseWSGIServer('localhost', port, self.wsgi_app)
self.server.timeout = self.timeout
return self
async def stop_server(self):
await super().stop_server()
self.server.server_close()
while self._requests:
self._requests.pop().cancel()
await asyncio.sleep(0, loop=self.loop)
async def wait_request(self):
fut = self.loop.run_in_executor(None, self.server.handle_request)
self._requests.append(fut)
return await super().wait_request()
async def set_response(self, args, kwargs):
await super().set_response(args, kwargs)
fut = self._requests.pop(0)
await fut
def make_server(host,
port,
app=None,
threaded=False,
processes=1,
request_handler=None,
passthrough_errors=False,
ssl_context=None):
"""Create a new server instance that is either threaded, or forks
or just processes one request after another.
"""
if threaded and processes > 1:
raise ValueError("cannot have a multithreaded and "
"multi process server.")
elif threaded:
# Override here
return ThreadedWSGIServer(host, port, app, request_handler,
passthrough_errors, ssl_context)
elif processes > 1:
return ForkingWSGIServer(host, port, app, processes, request_handler,
passthrough_errors, ssl_context)
else:
return BaseWSGIServer(host, port, app, request_handler,
passthrough_errors, ssl_context)
def run(self):
server = BaseWSGIServer(self.host, self.port, self.handle_request,
_QuietHandler)
server.log = lambda *args, **kwargs: None
log.info('Serving profiles on port {}'.format(self.port))
server.serve_forever()
def run(self):
server = BaseWSGIServer(self.host, self.port, self.handle_request,
_QuietHandler)
logger.info('Serving profiles on port {}'.format(self.port))
server.serve_forever()
def run(self):
server = BaseWSGIServer(self.host, self.port, self.handle_request,
_QuietHandler)
server.log = lambda *args, **kwargs: None
log.info('Serving profiles on port {}'.format(self.port))
server.serve_forever()
def run(self):
server = BaseWSGIServer(self.host, self.port, self.handle_request,
_QuietHandler)
server.log = lambda *args, **kwargs: None
server.serve_forever()
def start_app(app, ssl):
server = BaseWSGIServer(host='localhost', port=0, app=app)
server.my_extra = None
thread = threading.Thread(target=server.serve_forever, daemon=True)
thread.start()
return server
async def start_server(self, port, **kwargs):
await super().start_server(**kwargs)
self.server = BaseWSGIServer('localhost', port, self.wsgi_app)
self.server.timeout = self.timeout
return self
