如何停止 Tornado 网络服务器？

Question

我一直在玩 Tornado Web 服务器，并且已经到了我想停止 Web 服务器的地步（因为单元测试期间的示例）。以下简单示例Tornado 网页上存在：

import tornado.ioloop
import tornado.web

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, world")

application = tornado.web.Application([
    (r"/", MainHandler),
])

if __name__ == "__main__":
    application.listen(8888)
    tornado.ioloop.IOLoop.instance().start()

一次 tornado.ioloop.IOLoop.instance().start () 被调用，它会阻塞程序（或当前线程）。阅读 IOLoop 对象的源代码给出stop 函数文档中的这个示例：

To use asynchronous methods from otherwise-synchronous code (such as
unit tests), you can start and stop the event loop like this:
  ioloop = IOLoop()
  async_method(ioloop=ioloop, callback=ioloop.stop)
  ioloop.start()
ioloop.start() will return after async_method has run its callback,
whether that callback was invoked before or after ioloop.start.

但是，我不知道如何将其集成到我的程序中。我实际上有一个封装 Web 服务器的类（有自己的 start 和 stop 函数），但是一旦我调用 start，程序（或测试）就会无论如何当然会阻塞。

我尝试在另一个进程中启动 Web 服务器（使用 multiprocessing 包）。这是包装 Web 服务器的类：

class Server:
    def __init__(self, port=8888):
        self.application = tornado.web.Application([ (r"/", Handler) ])

        def server_thread(application, port):
            http_server = tornado.httpserver.HTTPServer(application)
            http_server.listen(port)
            tornado.ioloop.IOLoop.instance().start()

        self.process = Process(target=server_thread,
                               args=(self.application, port,))

    def start(self):
        self.process.start()

    def stop(self):
        ioloop = tornado.ioloop.IOLoop.instance()
        ioloop.add_callback(ioloop.stop)

但是，stop 似乎并没有完全停止 Web 服务器，因为即使使用此测试设置，它仍在下一个测试中运行：

def setup_method(self, _function):
    self.server = Server()
    self.server.start()
    time.sleep(0.5)  # Wait for web server to start

def teardown_method(self, _function):
    self.kstore.stop()
    time.sleep(0.5)

How can I start and stop a Tornado Web server from在 Python 程序中？

Answer 1

只需在 start() 之前添加以下内容：

IOLoop.instance().add_timeout(10,IOLoop.instance().stop)

它将在循环中将停止函数注册为回调，并在开始后 10 秒启动它

Answer 2

在 multiprocessing.Process 下运行时，Tornado 的 IOloop.instance() 无法从外部信号停止。

我想出的唯一始终有效的解决方案是使用 Process.terminate()：

import tornado.ioloop, tornado.web
import time
import multiprocessing

class Handler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, world")

application = tornado.web.Application([ (r"/", Handler) ])

class TornadoStop(Exception):
    pass
def stop():
    raise TornadoStop
class worker(multiprocessing.Process):
    def __init__(self):
        multiprocessing.Process.__init__(self)
        application.listen(8888)
        self.ioloop = tornado.ioloop.IOLoop.instance()

    def run(self):
        self.ioloop.start()

    def stop(self, timeout = 0):
        self.ioloop.stop()
        time.sleep(timeout)
        self.terminate()



if __name__ == "__main__":

    w = worker()
    print 'starting server'
    w.start()
    t = 2
    print 'waiting {} seconds before stopping'.format(t)
    for i in range(t):
        time.sleep(1)
        print i
    print 'stopping'
    w.stop(1)
    print 'stopped'

Answer 3

我们希望结合使用 multiprocessing.Process 和 tornado.ioloop.IOLoop 来解决 cPython GIL 的问题，以提高性能和独立性。为了访问 IOLoop，我们需要使用队列来传递关闭信号。

这是一个简单的例子：

class Server(BokehServer)

    def start(self, signal=None):
        logger.info('Starting server on http://localhost:%d'
                    % (self.port))

        if signal is not None:
            def shutdown():
                if not signal.empty():
                    self.stop()
            tornado.ioloop.PeriodicCallback(shutdown, 1000).start()

        BokehServer.start(self)
        self.ioloop.start()

    def stop(self, *args, **kwargs):  # args important for signals
        logger.info('Stopping server...')
        BokehServer.stop(self)
        self.ioloop.stop()

流程

import multiprocessing as mp
import signal

from server import Server  # noqa

class ServerProcess(mp.Process):
    def __init__(self, *args, **kwargs):
        self.server = Server(*args, **kwargs)
        self.shutdown_signal = _mp.Queue(1)
        mp.Process.__init__(self)

        signal.signal(signal.SIGTERM, self.server.stop)
        signal.signal(signal.SIGINT, self.server.stop)

    def run(self):
        self.server.start(signal=self.shutdown_signal)

    def stop(self):
        self.shutdown_signal.put(True)

if __name__ == '__main__':
    p = ServerProcess()
    p.start()

干杯！

Answer 4

如果您不想打扰线程，您可以捕获键盘中断信号：

try:
    tornado.ioloop.IOLoop.instance().start()
# signal : CTRL + BREAK on windows or CTRL + C on linux
except KeyboardInterrupt:
    tornado.ioloop.IOLoop.instance().stop()

Answer 5

Zaar Hai 的解决方案存在一个问题，即它使套接字保持打开状态。我正在寻找停止 Tornado 的解决方案的原因是我正在针对我的应用程序服务器运行单元测试，并且我需要一种方法在测试之间启动/停止服务器以获得清晰的状态（空会话等）。通过将套接字保持打开状态，第二个测试总是会遇到 地址已在使用 错误。所以我想到了以下内容：

import logging as log
from time import sleep
from threading import Thread

import tornado
from tornado.httpserver import HTTPServer


server = None
thread = None


def start_app():
    def start():
        global server
        server = HTTPServer(create_app())
        server.listen(TEST_PORT, TEST_HOST)
        tornado.ioloop.IOLoop.instance().start()
    global thread
    thread = Thread(target=start)
    thread.start()
    # wait for the server to fully initialize
    sleep(0.5)


def stop_app():
    server.stop()
    # silence StreamClosedError Tornado is throwing after it is stopped
    log.getLogger().setLevel(log.FATAL)
    ioloop = tornado.ioloop.IOLoop.instance()
    ioloop.add_callback(ioloop.stop)
    thread.join()

所以这里的主要思想是保留对 HTTPServer 实例的引用并调用其 stop() 方法。 create_app() 仅返回一个配置有处理程序的 Application 实例。现在您可以在单元测试中使用这些方法，如下所示：

class FoobarTest(unittest.TestCase):

    def setUp(self):
        start_app()

    def tearDown(self):
        stop_app()

    def test_foobar(self):
        # here the server is up and running, so you can make requests to it
        pass

Answer 6

要停止整个 ioloop，只需在完成单元测试后调用 ioloop.stop 方法即可。 （请记住，唯一的（已记录的）线程安全方法是 ioloop.add_callback，即，如果单元测试由另一个线程执行，您可以将停止调用包装在回调中）

如果它足以停止您调用的 http Web 服务器httpserver.stop() 方法

Answer 7

如果您需要这种行为进行单元测试，请查看 tornado。测试.AsyncTestCase。

默认情况下，会为每个测试构建一个新的 IOLoop，并可作为 self.io_loop 使用。这个IOLoop应该用在HTTP客户端/服务器等的构造中。如果被测试的代码需要全局IOLoop，子类应该重写get_new_ioloop来返回它。

如果您需要出于其他目的启动和停止 IOLoop，并且由于某种原因无法从回调中调用 ioloop.stop()，则可以使用多线程实现。然而，为了避免竞争条件，您需要同步对 ioloop 的访问，这实际上是不可能的。类似下面的情况将导致死锁：

线程 1：

with lock:
    ioloop.start()

线程 2：

with lock:
    ioloop.stop()

因为线程 1 永远不会释放锁（start() 是阻塞的），而线程 2 将等待直到锁被释放以停止 ioloop。

唯一的方法是让线程 2 调用 ioloop.add_callback(ioloop.stop)，这将在事件循环的下一次迭代中调用线程 1 上的 stop()。请放心，ioloop.add_callback() 是线程安全的。

Answer 8

这是如何从另一个线程停止 Torando 的解决方案。 Schildmeijer 提供了一个很好的提示，但我花了一段时间才真正弄清楚最终的可行示例。

请看下面：

import threading
import tornado.ioloop
import tornado.web
import time


class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, world!\n")

def start_tornado(*args, **kwargs):
    application = tornado.web.Application([
        (r"/", MainHandler),
    ])
    application.listen(8888)
    print "Starting Torando"
    tornado.ioloop.IOLoop.instance().start()
    print "Tornado finished"

def stop_tornado():
    ioloop = tornado.ioloop.IOLoop.instance()
    ioloop.add_callback(ioloop.stop)
    print "Asked Tornado to exit"

def main():

    t = threading.Thread(target=start_tornado)  
    t.start()

    time.sleep(5)

    stop_tornado()
    t.join()

if __name__ == "__main__":
    main()

Answer 9

我刚刚遇到这个问题并自己发现了这个问题，并使用该线程中的信息得出了以下结论。我只是简单地将我的工作独立 Tornado 代码（从所有示例中复制）并将实际的起始代码移至一个函数中。然后我将该函数称为线程线程。我的情况有所不同，因为线程调用是根据我刚刚导入的 startTornado 和 stopTornado 例程的现有代码完成的。

上面的建议似乎很有效，所以我想我会提供缺少的示例代码。我在 Linux 下的 FC16 系统上测试了这段代码（并修复了我最初的 type-o）。

import tornado.ioloop, tornado.web

class Handler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, world")

application = tornado.web.Application([ (r"/", Handler) ])

def startTornado():
    application.listen(8888)
    tornado.ioloop.IOLoop.instance().start()

def stopTornado():
    tornado.ioloop.IOLoop.instance().stop()

if __name__ == "__main__":
    import time, threading
    threading.Thread(target=startTornado).start()
    print "Your web server will self destruct in 2 minutes"
    time.sleep(120)
    stopTornado()

希望这对下一个人有帮助。