Diese Frage hat hier bereits eine Antwort:

Wir führen einen Tornado 3.0-Dienst auf einem RedHat-Betriebssystem aus und erhalten die folgende Fehlermeldung:

[E 140102 17:07:37 ioloop:660] Exception in I/O handler for fd 11
    Traceback (most recent call last):
      File "/usr/local/lib/python2.7/dist-packages/tornado/ioloop.py", line 653, in start
        self._handlers[fd](fd, events)
      File "/usr/local/lib/python2.7/dist-packages/tornado/stack_context.py", line 241, in wrapped
        callback(*args, **kwargs)
      File "/usr/local/lib/python2.7/dist-packages/tornado/netutil.py", line 136, in accept_handler
        connection, address = sock.accept()
      File "/usr/lib/python2.7/socket.py", line 202, in accept
    error: [Errno 24] Too many open files

Aber wir konnten nicht herausfinden, was das bedeutet.

Unser Tornado-Code lautet wie folgt:

import sys
from tornado.ioloop import IOLoop
from tornado.options import parse_command_line, define, options
from tornado.httpserver import HTTPServer
from tornado.netutil import bind_sockets
import tornado
sys.path.append("..")

from tornado.web import  RequestHandler, Application
from shared.bootstrap import *
from time import time
from clients import ClientFactory

from shared.configuration   import Config
from shared.logger          import Logger

from algorithms.neighborhood.application import NeighborhoodApplication
import traceback

define('port', default=8000, help="Run on the given port", type=int)
define('debug', default=True, help="Run application in debug mode", type=bool)

class WService(RequestHandler):

    _clients = {}

    def prepare(self):
        self._start_time = time()
        RequestHandler.prepare(self)

    def get(self, algorithm = None):

        self.add_header('Content-type', 'application/json')

        response = {'skus' : []}

        algorithm = 'neighborhood' if not algorithm else algorithm

        try:
            if not algorithm in self._clients:
                self._clients[algorithm] = ClientFactory.get_instance(algorithm)

            arguments = self.get_arguments_by_client(self._clients[algorithm].get_expected_arguments())

            response['skus'] = app.get_manager().make_recommendations(arguments)
            self.write(response)

        except Exception as err:
            self.write(response)
            error("Erro: " + str(err))

    def get_arguments_by_client(self, expected_arguments):
        arguments = {}
        for key in expected_arguments:
            arguments[key] = self.get_argument(key, expected_arguments[key])

        return arguments

    def on_connection_close(self):
        self.finish({'skus':[]})
        RequestHandler.on_connection_close(self)

    def on_finish(self):
        response_time = 1000.0 *(time() - self._start_time)
        log("%d %s %.2fms" % (self.get_status(), self._request_summary(), response_time))
        RequestHandler.on_finish(self)

def handling_exception(signal, frame):
    error('IOLoop blocked for %s seconds in\n%s\n\n' % ( io_loop._blocking_signal_threshold, ''.join(traceback.format_stack(frame)[-3:])))

if __name__ == "__main__":

    configuration = Config()
    Logger.configure(configuration.get_configs('logger'))

    app = NeighborhoodApplication({
                                   'application': configuration.get_configs('neighborhood'),
                                   'couchbase':   configuration.get_configs('couchbase'),
                                   'stock':       configuration.get_configs('stock')
                                   })
    app.run()
    log("Neighborhood Matrices successfully created...")
    log("Initiating Tornado Service...")

    parse_command_line()

    application = Application([
                               (r'/(favicon.ico)', tornado.web.StaticFileHandler, {"path": "./images/"}),
                               (r"/(.*)", WService)
                               ], **{'debug':options.debug, 'x-headers' : True})

    sockets = bind_sockets(options.port, backlog=1024)
    server = HTTPServer(application)
    server.add_sockets(sockets)

    io_loop = IOLoop.instance()
    io_loop.set_blocking_signal_threshold(.05, handling_exception)
    io_loop.start()

Es ist ein sehr einfaches Skript, im Grunde bekommt es die URL, verarbeitet sie in dermake_recommendation Funktion und sendet die Antwort zurück.

Wir haben versucht, eine Tornado-Zeitüberschreitung von 50 ms durch die einzustellenio_loop.set_blocking_signal_threshold Funktioniert, da die Verarbeitung der URL manchmal so lange dauert.

Das System empfängt ungefähr 8000 Anfragen pro Minute und hat ungefähr 30 Minuten lang einwandfrei funktioniert, aber danach hat es begonnen, den Fehler "zu viele Dateien" auszulösen und ist zusammengebrochen. Im Allgemeinen dauerte die Verarbeitung der Anforderungen etwa 20 ms, doch als der Fehler auftrat, erhöhte sich der Zeitaufwand plötzlich auf Sekunden.

Wir haben versucht zu sehen, wie viele Verbindungen der Port 8000 hatte und es gab mehrere offene Verbindungen, die alle den Status "ESTABLISHED" hatten.

Stimmt etwas in unserem Tornado-Skript nicht? Wir glauben, dass unsere Timeout-Funktion nicht richtig funktioniert, aber für das, was wir bisher recherchiert haben, scheint alles in Ordnung zu sein.

Wenn Sie weitere Informationen benötigen, lassen Sie es mich bitte wissen.

Danke im Voraus,