Как остановить веб-сервер Tornado?

Я только что столкнулся с этим и сам нашел эту проблему, и, используя информацию из этой темы, пришел к следующему. Я просто взял свой рабочий автономный код Tornado (скопированный из всех примеров) и переместил исходный код в функцию. Затем я назвал функцию потоковым потоком. Мой случай отличается тем, что вызов многопоточности был выполнен из моего существующего кода, где я только что импортировал подпрограммы startTornado и stopTornado.

Приведенное выше предложение, похоже, отлично сработало, поэтому я решил предоставить отсутствующий код примера. Я протестировал этот код под Linux в системе FC16 (и исправил свой первоначальный тип-о).

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()

Надеюсь, это поможет следующему человеку.

Вот решение, как остановить 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()

Если вы не хотите возиться с потоками, вы можете поймать сигнал прерывания клавиатуры:

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

Чтобы остановить весь ioloop, вы просто вызываете метод ioloop.stop после завершения модульного теста. (Помните, что единственным (задокументированным) потокобезопасным методом является ioloop.add_callback, т.е. если модульные тесты выполняются другим потоком, вы можете обернуть вызов остановки в обратный вызов)

Если этого достаточно, чтобы остановить веб-сервер http, вы вызываете https://github.com/facebook/tornado/blob/master/tornado/httpserver.py. .stop() метод

Есть проблема с решением Zaar Hai, а именно то, что оно оставляет сокет открытым. Причина, по которой я искал решение для остановки Tornado, заключается в том, что я запускаю модульные тесты на своем сервере приложений, и мне нужен был способ запуска/остановки сервера между тестами, чтобы иметь четкое состояние (пустой сеанс и т. д.). Оставляя сокет открытым, второй тест всегда приводил к ошибке Address already in use. Итак, я придумал следующее:

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

Если вам нужно такое поведение для модульного тестирования, взгляните на 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 будет ждать, пока блокировка не будет снята, чтобы остановить iloop.

Единственный способ сделать это для потока 2 — вызвать ioloop.add_callback(ioloop.stop), который вызовет stop() в потоке 1 в следующей итерации цикла событий. Будьте уверены, ioloop.add_callback() потокобезопасен.

У Ioloop.instance() Tornado возникают проблемы с остановкой из-за внешнего сигнала при запуске в multiprocessing.Process.

Единственное решение, которое я придумал, которое работает постоянно, — это использование 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'

Мы хотим использовать multiprocessing.Process с tornado.ioloop.IOLoop, чтобы обойти cPython GIL для повышения производительности и независимости. Чтобы получить доступ к IOLoop, нам нужно использовать Queue для передачи сигнала выключения.

Вот минималистичный пример:

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()

Ваше здоровье!

Просто добавьте это перед start():

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

Он зарегистрирует функцию остановки как обратный вызов в цикле и запустит ее через 10 секунд после запуска.