def run(self, app, host=None, port=None, **kwargs):
        """Run the SocketIO web server.

        :param app: The Flask application instance.
        :param host: The hostname or IP address for the server to listen on.
                     Defaults to 127.0.0.1.
        :param port: The port number for the server to listen on. Defaults to
                     5000.
        :param debug: ``True`` to start the server in debug mode, ``False`` to
                      start in normal mode.
        :param use_reloader: ``True`` to enable the Flask reloader, ``False``
                             to disable it.
        :param extra_files: A list of additional files that the Flask
                            reloader should watch. Defaults to ``None``
        :param log_output: If ``True``, the server logs all incomming
                           connections. If ``False`` logging is disabled.
                           Defaults to ``True`` in debug mode, ``False``
                           in normal mode. Unused when the threading async
                           mode is used.
        :param kwargs: Additional web server options. The web server options
                       are specific to the server used in each of the supported
                       async modes. Note that options provided here will
                       not be seen when using an external web server such
                       as gunicorn, since this method is not called in that
                       case.
        """
        if host is None:
            host = '127.0.0.1'
        if port is None:
            server_name = app.config['SERVER_NAME']
            if server_name and ':' in server_name:
                port = int(server_name.rsplit(':', 1)[1])
            else:
                port = 5000

        debug = kwargs.pop('debug', app.debug)
        log_output = kwargs.pop('log_output', debug)
        use_reloader = kwargs.pop('use_reloader', debug)
        extra_files = kwargs.pop('extra_files', None)

        app.debug = debug
        if app.debug and self.server.eio.async_mode != 'threading':
            # put the debug middleware between the SocketIO middleware
            # and the Flask application instance
            #
            #    mw1   mw2   mw3   Flask app
            #     o ---- o ---- o ---- o
            #    /
            #   o Flask-SocketIO
            #    \  middleware
            #     o
            #  Flask-SocketIO WebSocket handler
            #
            # BECOMES
            #
            #  dbg-mw   mw1   mw2   mw3   Flask app
            #     o ---- o ---- o ---- o ---- o
            #    /
            #   o Flask-SocketIO
            #    \  middleware
            #     o
            #  Flask-SocketIO WebSocket handler
            #
            self.sockio_mw.wsgi_app = DebuggedApplication(self.sockio_mw.wsgi_app,
                                                          evalex=True)

        if self.server.eio.async_mode == 'threading':
            from werkzeug._internal import _log
            _log('warning', 'WebSocket transport not available. Install '
                            'eventlet or gevent and gevent-websocket for '
                            'improved performance.')
            app.run(host=host, port=port, threaded=True,
                    use_reloader=use_reloader, **kwargs)
        elif self.server.eio.async_mode == 'eventlet':
            def run_server():
                import eventlet
                import eventlet.wsgi
                import eventlet.green
                addresses = eventlet.green.socket.getaddrinfo(host, port)
                if not addresses:
                    raise RuntimeError('Could not resolve host to a valid address')
                eventlet_socket = eventlet.listen(addresses[0][4], addresses[0][0])

                # If provided an SSL argument, use an SSL socket
                ssl_args = ['keyfile', 'certfile', 'server_side', 'cert_reqs',
                            'ssl_version', 'ca_certs',
                            'do_handshake_on_connect', 'suppress_ragged_eofs',
                            'ciphers']
                ssl_params = {k: kwargs[k] for k in kwargs if k in ssl_args}
                if len(ssl_params) > 0:
                    for k in ssl_params:
                        kwargs.pop(k)
                    ssl_params['server_side'] = True  # Listening requires true
                    eventlet_socket = eventlet.wrap_ssl(eventlet_socket,
                                                        **ssl_params)

                eventlet.wsgi.server(eventlet_socket, app,
                                     log_output=log_output, **kwargs)

            if use_reloader:
                run_with_reloader(run_server, extra_files=extra_files)
            else:
                run_server()
        elif self.server.eio.async_mode == 'gevent':
            from gevent import pywsgi
            try:
                from geventwebsocket.handler import WebSocketHandler
                websocket = True
            except ImportError:
                websocket = False

            log = 'default'
            if not log_output:
                log = None
            if websocket:
                self.wsgi_server = pywsgi.WSGIServer(
                    (host, port), app, handler_class=WebSocketHandler,
                    log=log, **kwargs)
            else:
                self.wsgi_server = pywsgi.WSGIServer((host, port), app,
                                                     log=log, **kwargs)

            if use_reloader:
                # monkey patching is required by the reloader
                from gevent import monkey
                monkey.patch_all()

                def run_server():
                    self.wsgi_server.serve_forever()

                run_with_reloader(run_server, extra_files=extra_files)
            else:
                self.wsgi_server.serve_forever()
def run ( self , app , host = None , port = None , ** kwargs ) : if host is None : host = '127.0.0.1' if port is None : server_name = app . config [ 'SERVER_NAME' ] if server_name and ':' in server_name : port = int ( server_name . rsplit ( ':' , 1 ) [ 1 ] ) else : port = 5000 debug = kwargs . pop ( 'debug' , app . debug ) log_output = kwargs . pop ( 'log_output' , debug ) use_reloader = kwargs . pop ( 'use_reloader' , debug ) extra_files = kwargs . pop ( 'extra_files' , None ) app . debug = debug if app . debug and self . server . eio . async_mode != 'threading' : self . sockio_mw . wsgi_app = DebuggedApplication ( self . sockio_mw . wsgi_app , evalex = True ) if self . server . eio . async_mode == 'threading' : from werkzeug . _internal import _log _log ( 'warning' , 'WebSocket transport not available. Install ' 'eventlet or gevent and gevent-websocket for ' 'improved performance.' ) app . run ( host = host , port = port , threaded = True , use_reloader = use_reloader , ** kwargs ) elif self . server . eio . async_mode == 'eventlet' : def run_server ( ) : import eventlet import eventlet . wsgi import eventlet . green addresses = eventlet . green . socket . getaddrinfo ( host , port ) if not addresses : raise RuntimeError ( 'Could not resolve host to a valid address' ) eventlet_socket = eventlet . listen ( addresses [ 0 ] [ 4 ] , addresses [ 0 ] [ 0 ] ) ssl_args = [ 'keyfile' , 'certfile' , 'server_side' , 'cert_reqs' , 'ssl_version' , 'ca_certs' , 'do_handshake_on_connect' , 'suppress_ragged_eofs' , 'ciphers' ] ssl_params = { k : kwargs [ k ] for k in kwargs if k in ssl_args } if len ( ssl_params ) > 0 : for k in ssl_params : kwargs . pop ( k ) ssl_params [ 'server_side' ] = True eventlet_socket = eventlet . wrap_ssl ( eventlet_socket , ** ssl_params ) eventlet . wsgi . server ( eventlet_socket , app , log_output = log_output , ** kwargs ) if use_reloader : run_with_reloader ( run_server , extra_files = extra_files ) else : run_server ( ) elif self . server . eio . async_mode == 'gevent' : from gevent import pywsgi try : from geventwebsocket . handler import WebSocketHandler websocket = True except ImportError : websocket = False log = 'default' if not log_output : log = None if websocket : self . wsgi_server = pywsgi . WSGIServer ( ( host , port ) , app , handler_class = WebSocketHandler , log = log , ** kwargs ) else : self . wsgi_server = pywsgi . WSGIServer ( ( host , port ) , app , log = log , ** kwargs ) if use_reloader : from gevent import monkey monkey . patch_all ( ) def run_server ( ) : self . wsgi_server . serve_forever ( ) run_with_reloader ( run_server , extra_files = extra_files ) else : self . wsgi_server . serve_forever ( )
Run the SocketIO web server.

        :param app: The Flask application instance.
        :param host: The hostname or IP address for the server to listen on.
                     Defaults to 127.0.0.1.
        :param port: The port number for the server to listen on. Defaults to
                     5000.
        :param debug: ``True`` to start the server in debug mode, ``False`` to
                      start in normal mode.
        :param use_reloader: ``True`` to enable the Flask reloader, ``False``
                             to disable it.
        :param extra_files: A list of additional files that the Flask
                            reloader should watch. Defaults to ``None``
        :param log_output: If ``True``, the server logs all incomming
                           connections. If ``False`` logging is disabled.
                           Defaults to ``True`` in debug mode, ``False``
                           in normal mode. Unused when the threading async
                           mode is used.
        :param kwargs: Additional web server options. The web server options
                       are specific to the server used in each of the supported
                       async modes. Note that options provided here will
                       not be seen when using an external web server such
                       as gunicorn, since this method is not called in that
                       case.