def runserver(ip, port, debug=False):  # pragma: no cover
    from cherrypy import wsgiserver
    from werkzeug.serving import run_with_reloader

    app = ErrorMiddleware(make_app(debug=debug))
    server = wsgiserver.CherryPyWSGIServer((ip, port), app, numthreads=30)
    run_with_reloader(server.start)

def run(app, host=None, port=None, debug=None, logger=logger):
    monkey.patch_all()

    address = get_address(host, port, app.config['SERVER_NAME'])

    if debug is not None:
        app.debug = debug

    if app.debug:
        #app.wsgi_app = DebuggedApplication(app.wsgi_app, evalex=True)
        server = WebSocketServer(address, app.wsgi_app, debug=debug)
        server._logger = logger

        logger.setLevel(logging.INFO)
        def run_server():
            server.serve_forever()
        if os.environ.get('WERKZEUG_RUN_MAIN') != 'true':
            server.logger.info(' * Running on http://%s:%d/' % address)
            server.logger.info(' * WebSocket enabled')
        run_with_reloader(run_server)
    else:
        server = WebSocketServer(address, app.wsgi_app, debug=debug)
        server._logger = logger
        server.serve_forever()
    return server

def serve(host, port, debug):
    quasimodo.app.debug = quasimodo.app.testing = debug

    if quasimodo.app.debug:
        run_with_reloader(functools.partial(quasimodo.run, host, port))
    else:
        quasimodo.run(host, port)

    def run(self, *args, **kwargs):

        worker_threads = kwargs["worker-threads"]
        assert worker_threads >= 0
        ping_address = kwargs["ping-address"]
        assert ping_address
        data_address = kwargs["data-address"]
        assert data_address
        poll_timeout = kwargs["poll-timeout"]
        assert poll_timeout

        workers = []

        def start():
            while any(map(lambda w: not w.stopped, workers)):
                for worker in workers:
                    worker.stop()
            while len(workers) > 0:
                workers.pop()

            for _ in range(worker_threads):
                workers.append(
                    backend.Worker(ping_address=ping_address, data_address=data_address, poll_timeout=poll_timeout)
                )

                workers[-1].start()

        try:
            run_with_reloader(start)
        except KeyboardInterrupt:
            while any(map(lambda w: not w.stopped, workers)):
                for worker in workers:
                    worker.stop()

    def __call__(self, app, host, port, use_debugger, use_reloader, threaded, processes, passthrough_errors):
        if use_debugger is None:
            use_debugger = app.debug
            if use_debugger is None:
                use_debugger = True
                if sys.stderr.isatty():
                    print("Debugging is on. DANGER: Do not allow random users to connect to this server.",
                          file=sys.stderr)
        if use_reloader is None:
            use_reloader = app.debug

        if use_debugger:
            from werkzeug.debug import DebuggedApplication
            app = DebuggedApplication(app, True)

        def run():
            from gevent.wsgi import WSGIServer
            gws = WSGIServer((host, port), app)
            gws.base_env['wsgi.multithread'] = threaded
            gws.base_env['wsgi.multiprocess'] = processes > 0
            gws.serve_forever()

        if use_reloader:
            from werkzeug.serving import run_with_reloader
            run_with_reloader(run)
        else:
            run()

    def run(app: flask.Flask, *,
            host='127.0.0.1', port=None, debug=False, loop=None):
        """Run Flask application on aiohttp

        :param app: Flask application
        :param host: host name or ip
        :param port: port (default is 5000)
        :param debug: debug?

        """
        # Check initialization status of flask app.
        if getattr(app, 'aiohttp_app', None) is None:
            raise RuntimeError(
                "This application is not initialized for Flask-aiohttp. "
                "Please initialize the app by `aio.init_app(app)`.")

        # Configure args
        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
        loop = loop or asyncio.get_event_loop()

        # Define run_server
        def run_server():
            # run_server can be called in another thread
            asyncio.set_event_loop(loop)
            coroutine = loop.create_server(
                app.aiohttp_app.make_handler(), host, port)
            loop.run_until_complete(coroutine)
            try:
                loop.run_forever()
            except KeyboardInterrupt:
                pass

        # Configure logging
        file_handler = logging.StreamHandler()
        app.logger.setLevel(logging.INFO)
        app.logger.addHandler(file_handler)

        if debug:
            # Logging
            app.logger.setLevel(logging.DEBUG)

            # Wrap WSGI app with werkzeug debugger.
            app.wsgi_app = wrap_wsgi_middleware(DebuggedApplication)(
                app.wsgi_app)

            if os.environ.get('WERKZEUG_RUN_MAIN') != 'true':
                app.logger.info(' * Running on http://{}:{}/'
                                .format(host, port))

            # Run with reloader
            run_with_reloader(run_server)
        else:
            app.logger.info(' * Running on http://{}:{}/'.format(host, port))
            run_server()

    def runServer(self):
        """Starts up the server. It (will) support different config options via the config plugin."""
        config = pm.getService("config")
        debug = config.get("flask.debug")
        cFCGI = config.get("flask.fcgi")
        host = config.get("flask.bind")
        app_port = config.get("flask.app_port")
        fcgi_port = config.get("flask.fcgi_port")
        must_have_client_cert = config.get("flask.force_client_cert")

        if cFCGI:
            logger.info("registering fcgi server at %s:%i", host, fcgi_port)
            from flup.server.fcgi import WSGIServer
            WSGIServer(self._app, bindAddress=(host, fcgi_port)).run()
        else:
            logger.info("registering app server at %s:%i", host, app_port)
            # do the following line manually, so we can intervene and adjust the ssl context
            # self._app.run(host=host, port=app_port, ssl_context='adhoc', debug=debug, request_handler=ClientCertHTTPRequestHandler)
            
            # the code from flask's `run...`
            # see https://github.com/mitsuhiko/flask/blob/master/flask/app.py
            options = {}
            try:
                # now the code from werkzeug's `run_simple(host, app_port, self._app, **options)`
                # see https://github.com/mitsuhiko/werkzeug/blob/master/werkzeug/serving.py
                from werkzeug.debug import DebuggedApplication
                import socket
                application = DebuggedApplication(self._app, True)

                # Set up an SSL context
                cert_path = expand_eisoil_path(config.get("delegatetools.trusted_cert_path"))
                cert_key_path = expand_eisoil_path(config.get("delegatetools.trusted_cert_keys_path"))

                context = SSL.Context(SSL.SSLv23_METHOD)
                context_crt = os.path.join(cert_path, "ch-cert.pem")
                context_key = os.path.join(cert_key_path, "ch-key.pem")
                try:
                    context.use_certificate_file(context_crt)
                    context.use_privatekey_file(context_key)
                except Exception as e:
                    logger.critical("error starting flask server. Cert or key is missing under %s", cert_path)
                    sys.exit(e)

                def inner():
                    # server = serving.make_server(host, app_port, self._app, False, 1, ClientCertHTTPRequestHandler, False, 'adhoc')
                    server = serving.make_server(host, app_port, self._app, False, 1, ClientCertHTTPRequestHandler, False, ssl_context=context)
                    # The following line is the reason why I copied all that code!
                    if must_have_client_cert:
                        server.ssl_context.set_verify(SSL.VERIFY_PEER | SSL.VERIFY_FAIL_IF_NO_PEER_CERT, lambda a,b,c,d,e: True)
                    # That's it
                    server.serve_forever()
                address_family = serving.select_ip_version(host, app_port)
                test_socket = socket.socket(address_family, socket.SOCK_STREAM)
                test_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
                test_socket.bind((host, app_port))
                test_socket.close()
                serving.run_with_reloader(inner, None, 1)
            finally:
                self._app._got_first_request = False

def main():
    p = parser()
    args = p.parse_args()
    def helper():
        run_args(args)
    if args.reload:
        run_with_reloader(helper)
    else:
        helper()

 def callback(info, *args, **kwargs):
     if self.with_reloader:
         app = info.load_app()
         if app.debug:
             def inner():
                 return self.command_callback(info, *args, **kwargs)
             run_with_reloader(inner, extra_files=get_reloader_extra_files())
             return
     self.command_callback(info, *args, **kwargs)

def start(mg):
    """Start WEB UI"""

    global manager
    manager = mg

    # Create sqlalchemy session for Flask usage
    global db_session
    db_session = scoped_session(sessionmaker(autocommit=False,
                                             autoflush=False,
                                             bind=manager.engine))
    if db_session is None:
        raise Exception('db_session is None')

    load_ui_plugins()

    # quick hack: since ui plugins may add tables to SQLAlchemy too and they're not initialized because create
    # was called when instantiating manager .. so we need to call it again
    from flexget.manager import Base
    Base.metadata.create_all(bind=manager.engine)

    app.register_blueprint(api)
    app.register_blueprint(api_schema)
    fire_event('webui.start')

    # Start Flask
    app.secret_key = os.urandom(24)

    set_exit_handler(stop_server)

    log.info('Starting server on port %s' % manager.options.webui.port)

    if manager.options.webui.autoreload:
        # Create and destroy a socket so that any exceptions are raised before
        # we spawn a separate Python interpreter and lose this ability.
        from werkzeug.serving import run_with_reloader
        reloader_interval = 1
        extra_files = None
        test_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        test_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        test_socket.bind((manager.options.webui.bind, manager.options.webui.port))
        test_socket.close()
        log.warning('Not starting scheduler, since autoreload is enabled.')
        run_with_reloader(start_server, extra_files, reloader_interval)
    else:
        # Start the scheduler
        manager.scheduler.start()
        start_server()

    log.debug('server exited')
    fire_event('webui.stop')
    manager.shutdown(finish_queue=False)

def run_wsgi_app_with_cherrypy(app, default_port=8081):
    parser = argparse.ArgumentParser(
        description='Milo Web Service')
    parser.add_argument(
        '--ip', nargs='?', default='localhost',
        help="defaults to %(default)s")
    parser.add_argument(
        '-p', '--port', type=int, default=default_port,
        help="defaults to %(default)s")
    parser.add_argument(
        '-d', '--debug', action='store_true', default=False,
        help="show traceback interpreter on error")
    parser.add_argument(
        '-n', '--threads', type=int, default=30,
        help="number of threads to use")
    parser.add_argument(
        '--port-start', type=int, default=None,
        help="starting port number")
    parser.add_argument(
        '--port-offset', type=int, default=None,
        help="0 based offset to be added to start-port to determine port")

    args = parser.parse_args()

    if args.port_start is not None and args.port_offset is not None:
        port = args.port_start + args.port_offset
    else:
        port = args.port

    if args.debug:
        from werkzeug.debug import DebuggedApplication
        from wsgiref.validate import validator
        app = DebuggedApplication(app, evalex=True)
        app = validator(app)

    from cherrypy import wsgiserver
    import signal
    server = wsgiserver.CherryPyWSGIServer(
        (args.ip, port), app, numthreads=args.threads)

    logger.info('Bringing up server on port %s', port)
    if args.debug:
        from werkzeug.serving import run_with_reloader
        run_with_reloader(server.start)
    else:
        def die_die_die_cherrypy(signum, frame):
            print die_message
            server.stop()
        signal.signal(signal.SIGINT, die_die_die_cherrypy)
        signal.signal(signal.SIGTERM, die_die_die_cherrypy)

        server.start()

    def run(self, host=None, port=None, debug=None, **options):
        from werkzeug.serving import make_server, run_with_reloader

        if host is None:
            host = '127.0.0.1'
        if port is None:
            server_name = self.config['SERVER_NAME']
            if server_name and ':' in server_name:
                port = int(server_name.rsplit(':', 1)[1])
            else:
                port = 5000
        if debug is not None:
            self.debug = bool(debug)

        hostname = host
        port = port
        application = self
        use_reloader = self.debug
        use_debugger = self.debug

        if use_debugger:
            from werkzeug.debug import DebuggedApplication
            application = DebuggedApplication(application, True)

        try:
            from .webdav import dav_app
        except ImportError as e:
            logger.error('WebDav interface not enabled: %r', e)
            dav_app = None
        if dav_app:
            from werkzeug.wsgi import DispatcherMiddleware
            application = DispatcherMiddleware(application, {
                '/dav': dav_app
            })

        def inner():
            self.server = make_server(hostname, port, application)
            self.server.serve_forever()

        if os.environ.get('WERKZEUG_RUN_MAIN') != 'true':
            display_hostname = hostname != '*' and hostname or 'localhost'
            if ':' in display_hostname:
                display_hostname = '[%s]' % display_hostname
            self.logger.info('webui running on http://%s:%d/', display_hostname, port)

        if use_reloader:
            run_with_reloader(inner)
        else:
            inner()

 def run(self):
     try:
         print 'Listening at %s port %d...' % (self.host, self.port)
         SocketIONamespace.set_app_class(self.app_class)
         if self.debug:
             self.flask_app = SocketIODebugger(self.flask_app,
                 evalex=True, namespace=SocketIONamespace)
         server = SocketIOServer((self.host, self.port), self.flask_app,
             resource='socket.io', policy_server=False)
         if self.debug:
             run_with_reloader(server.serve_forever)
         else:
             server.serve_forever()
     except KeyboardInterrupt:
         print '\rShutting down...'

 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
     #Don't allow override of resource, otherwise allow SocketIOServer kwargs to be passed through
     kwargs.pop('resource', None)
     self.server = SocketIOServer((host, port), app.wsgi_app, resource='socket.io', **kwargs)
     if app.debug:
         def run_server():
             self.server.serve_forever()
         run_with_reloader(run_server)
     else:
         self.server.serve_forever()

    def runServer(self):
        """Starts up the server. It (will) support different config options via the config plugin."""
        config = pm.getService("config")
        debug = config.get("flask.debug")
        cFCGI = config.get("flask.fcgi")
        host = config.get("flask.bind")
        app_port = config.get("flask.app_port")
        fcgi_port = config.get("flask.fcgi_port")
        must_have_client_cert = config.get("flask.force_client_cert")

        if cFCGI:
            logger.info("registering fcgi server at %s:%i", host, fcgi_port)
            from flup.server.fcgi import WSGIServer
            WSGIServer(self._app, bindAddress=(host, fcgi_port)).run()
        else:
            logger.info("registering app server at %s:%i", host, app_port)
            # this workaround makes sure that the client cert can be acquired later (even when running the development server)
            # copied all this stuff from the actual flask implementation, so we can intervene and adjust the ssl context
            # self._app.run(host=host, port=app_port, ssl_context='adhoc', debug=debug, request_handler=ClientCertHTTPRequestHandler)
            
            # the code from flask's `run...`
            # see https://github.com/mitsuhiko/flask/blob/master/flask/app.py
            options = {}
            try:
                # now the code from werkzeug's `run_simple(host, app_port, self._app, **options)`
                # see https://github.com/mitsuhiko/werkzeug/blob/master/werkzeug/serving.py
                from werkzeug.debug import DebuggedApplication
                import socket
                application = DebuggedApplication(self._app, True)
                def inner():
                    server = serving.make_server(host, app_port, self._app, False, 1, ClientCertHTTPRequestHandler, False, 'adhoc')
                    # The following line is the reason why I copied all that code!
                    if must_have_client_cert:
                        server.ssl_context.set_verify(SSL.VERIFY_PEER | SSL.VERIFY_FAIL_IF_NO_PEER_CERT, lambda a,b,c,d,e: True)
                    # That's it
                    server.serve_forever()
                address_family = serving.select_ip_version(host, app_port)
                test_socket = socket.socket(address_family, socket.SOCK_STREAM)
                test_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
                test_socket.bind((host, app_port))
                test_socket.close()
                serving.run_with_reloader(inner, None, 1)
            finally:
                self._app._got_first_request = False

def run(info, host, port, reload, debugger, eager_loading):
    """Runs a local development server for the Flask-SocketIO application.

    The reloader and debugger are by default enabled if the debug flag of
    Flask is enabled and disabled otherwise.
    """
    debug = get_debug_flag()
    if reload is None:
        reload = bool(debug)
    if debugger is None:
        debugger = bool(debug)
    if eager_loading is None:
        eager_loading = not reload

    # Extra startup messages.  This depends a bit on Werkzeug internals to
    # not double execute when the reloader kicks in.
    if os.environ.get('WERKZEUG_RUN_MAIN') != 'true':
        # If we have an import path we can print it out now which can help
        # people understand what's being served.  If we do not have an
        # import path because the app was loaded through a callback then
        # we won't print anything.
        if info.app_import_path is not None:
            print(' * Serving Flask-SocketIO app "%s"' % info.app_import_path)
        if debug is not None:
            print(' * Forcing debug mode %s' % (debug and 'on' or 'off'))

    def run_server():
        app = info.load_app()
        if 'socketio' not in app.extensions:
            # flask-socketio is installed, but it isn't in this application
            # so we invoke Flask's original run command
            run_index = sys.argv.index('run')
            sys.argv = sys.argv[run_index:]
            return run_command()
        socketio = app.extensions['socketio']
        socketio.run(app, host=host, port=port, debug=debugger,
                     use_reloader=False, log_output=debugger)

    if reload:
        from werkzeug.serving import run_with_reloader
        run_with_reloader(run_server)
    else:
        run_server()

def main():
    parser = ArgumentParser(description=__doc__, version='Mongo Task Queue (mtq) v%s'
                            % mtq.__version__, add_help=False)
    parser.add_argument('-c', '--config', help='Python module containing MTQ settings.')

    args, _ = parser.parse_known_args()
    config = config_dict(args.config)
    add_extra_arguments = config.get('extra_arguments')
    init_config = config.get('init')

    parser = ArgumentParser(description=__doc__,
                            version='Mongo Task Queue (mtq) v%s' % mtq.__version__, add_help=True)
    parser.add_argument('-c', '--config', help='Python module containing MTQ settings.')

    parser.add_argument('queues', nargs='*', default=['default'], help='The queues to listen on (default: %(default)r)')
    parser.add_argument('-r', '--reloader', action='store_true', help='Reload the worker when it detects a change')
    parser.add_argument('-p', '--poll-interval', help='Sleep interval to check for jobs', default=3, type=int)
    parser.add_argument('-t', '--tags', nargs='*', help='only process jobs which contain all of the tags', default=[])
    parser.add_argument('-l', '--log-output', action='store_true', help='Store job and woker ouput in the db, seealso mtq-tail')
    parser.add_argument('-1', '--one', action='store_true',
                        help='Process only the first job')
    parser.add_argument('--backlog', '--list-jobs', action='store_true',
                        help='List backlog of jobs and exit', dest='backlog')
    parser.add_argument('-b', '--batch', action='store_true',
                        help='Process jobs until the queue is empty, then exit')
    parser.add_argument('-j', '--job-id', type=object_id,
                        help='Process the job (even if it has already been processed)')
    parser.add_argument('-f', '--failed', action='store_true',
                        help='Process failed jobs')

    if add_extra_arguments:
        add_extra_arguments(parser)

    args = parser.parse_args()

    if init_config:
        init_config(args)

    if args.reloader:
        from werkzeug.serving import run_with_reloader
        run_with_reloader(lambda: aux(args))
    else:
        aux(args)

def gevent_run(app):
    from gevent.wsgi import WSGIServer
    import gevent.monkey
    from werkzeug.debug import DebuggedApplication
    gevent.monkey.patch_socket()
    run_app = app
    if app.config['DEBUG']:
        run_app = DebuggedApplication(app)

    def run_server():
        port = int(app.config.get('PORT', 5000))
        address = app.config.get('ADDRESS', '')
        print('Listening on http://%s:%d/' % (address or '0.0.0.0', port))
        http_server = WSGIServer((address, port), run_app)
        http_server.serve_forever()

    if app.config['DEBUG']:
        from werkzeug.serving import run_with_reloader
        run_with_reloader(run_server)
    else:
        run_server()

 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
     # don't allow override of resource, otherwise allow SocketIOServer 
     # kwargs to be passed through
     kwargs.pop('resource', None)
     self.server = SocketIOServer((host, port), app.wsgi_app, 
                                  resource='socket.io', **kwargs)
     if app.debug:
         def run_server():
             self.server.serve_forever()
         if os.environ.get('WERKZEUG_RUN_MAIN') != 'true':
             _log('info', ' * Running on http://%s:%d/' % (host, port))
         run_with_reloader(run_server)
     else:
         self.server.serve_forever()

    def run(self, host=None, port=None, debug=None, **options):
        from werkzeug.serving import make_server, run_with_reloader

        if host is None:
            host = '127.0.0.1'
        if port is None:
            server_name = self.config['SERVER_NAME']
            if server_name and ':' in server_name:
                port = int(server_name.rsplit(':', 1)[1])
            else:
                port = 5000
        if debug is not None:
            self.debug = bool(debug)

        #run_simple(host, port, self, **options)
        hostname = host
        port = port
        application = self
        use_reloader = self.debug
        use_debugger = self.debug

        if use_debugger:
            from werkzeug.debug import DebuggedApplication
            application = DebuggedApplication(application, True)

        def inner():
            self.server = make_server(hostname, port, application)
            self.server.serve_forever()

        if os.environ.get('WERKZEUG_RUN_MAIN') != 'true':
            display_hostname = hostname != '*' and hostname or 'localhost'
            if ':' in display_hostname:
                display_hostname = '[%s]' % display_hostname
            self.logger.info('webui running on http://%s:%d/', display_hostname, port)

        if use_reloader:
            run_with_reloader(inner)
        else:
            inner()