def start_server(config: Type[Config], task_definitions: Dict[str, Tuple[int, Callable]]): """ Starts the flask application using a cheroot WSGI server :param config: The configuration to use :param task_definitions: The background tasks, consisting of: - the name of the task - the time to wait before running the task again - a function that takes no arguments that executes the task :return: None """ if not config.TELEGRAM_API_KEY == "" \ and not config.TESTING \ and config.TELEGRAM_WHOAMI: # pragma: no cover try: config.initialize_telegram() Config.TELEGRAM_BOT_CONNECTION.bot.logger.setLevel(logging.WARNING) except TimedOut: print("Could not initialize telegram") sys.exit(1) task_definitions.update({"telegram_bg": (30, telegram_whoami)}) __start_background_tasks(task_definitions) app.logger.info("STARTING FLASK") server = Server(("0.0.0.0", config.HTTP_PORT), PathInfoDispatcher({"/": app})) try: server.start() except KeyboardInterrupt: server.stop()
def run_server(self, port=None): log.info("home_dir %s",config.get('DEFAULT', 'home_dir')) log.info("hydra_base_dir %s",config.get('DEFAULT', 'hydra_base_dir')) log.info("common_app_data_folder %s",config.get('DEFAULT', 'common_app_data_folder')) log.info("win_common_documents %s",config.get('DEFAULT', 'win_common_documents')) log.info("sqlite url %s",config.get('mysqld', 'url')) log.info("layout_xsd_path %s",config.get('hydra_server', 'layout_xsd_path')) log.info("default_directory %s",config.get('plugin', 'default_directory')) log.info("result_file %s",config.get('plugin', 'result_file')) log.info("plugin_xsd_path %s",config.get('plugin', 'plugin_xsd_path')) log.info("log_config_path %s",config.get('logging_conf', 'log_config_path')) if port is None: port = config.getint('hydra_server', 'port', 8080) domain = config.get('hydra_server', 'domain', '127.0.0.1') check_port_available(domain, port) spyne.const.xml_ns.DEFAULT_NS = 'soap_server.hydra_complexmodels' cp_wsgi_application = Server((domain,port), application, numthreads=10) log.info("listening to http://%s:%s", domain, port) log.info("wsdl is at: http://%s:%s/soap/?wsdl", domain, port) try: cp_wsgi_application.start() except KeyboardInterrupt: cp_wsgi_application.stop()
def run_webserver(): server = WSGIServer(bind_addr=(MY_IP, int(MY_PORT)), wsgi_app=app, numthreads=100) print( "[DDR_INSTALLER][INFO] ------------------------------------------------------------------------" ) print("[DDR_INSTALLER][INFO] Starting IDA plugin installation.") print( "[DDR_INSTALLER][INFO] Please go to your IDA machine and point your browser to:\n" ) print("[DDR_INSTALLER][INFO] http://{}:{}\n".format(MY_IP, MY_PORT)) print( "[DDR_INSTALLER][INFO] Once you are done installing the IDA plugin, hit Ctrl-C here to stop the" ) print("[DDR_INSTALLER][INFO] webserver and proceed with the installation.") print( "[DDR_INSTALLER][INFO] ------------------------------------------------------------------------" ) try: server.start() except KeyboardInterrupt: server.stop() except: print( "[DDR_INSTALLER][ERROR] Failed to start installation server. Please check if you" ) print( "[DDR_INSTALLER][ERROR] have configured a valid NGINX IP address above.\n" ) raise
class WebServer(Thread): def __init__(self, port=defaults.WEB_SERVER_PORT, static_path=TESTPLAN_UI_STATIC_DIR, data_path='./', report_name=TESTPLAN_REPORT): super(WebServer, self).__init__() self.host = defaults.WEB_SERVER_HOSTNAME self.port = port self.static_path = static_path self.data_path = data_path self.report_name = report_name self.server = None def _configure_flask_app(self): app.config['STATIC_PATH'] = self.static_path app.config['DATA_PATH'] = self.data_path app.config['TESTPLAN_REPORT_NAME'] = self.report_name app.static_folder = os.path.abspath( os.path.join(app.config['STATIC_PATH'], 'testing', 'build', 'static')) def run(self): self._configure_flask_app() dispatcher = PathInfoDispatcher({'/': app}) self.server = WSGIServer((self.host, self.port), dispatcher) self.server.start() def ready(self): if self.server: return self.server.ready return False def stop(self): self.server.stop()
def runtime(self, flask_instance: Flask, mode: int = ENABLE_FLASK): """ This method deploys a REST endpoint as using different technologies according to the "mode" value. This endpoint will listen for incoming REST requests on different route paths. """ if mode == ENABLE_FLASK: # simply run Flask flask_instance.run(host=self._listening_address, port=self._listening_port, threaded=True) elif mode == ENABLE_CHERRYPY: # Run Flask wrapped by Cherrypy cherrypy.tree.graft(flask_instance, "/") cherrypy.config.update({ "server.socket_host": self._listening_address, "server.socket_port": self._listening_port, "engine.autoreload.on": False, }) cherrypy.engine.start() cherrypy.engine.block() elif mode == ENABLE_WSGISERVER: # Run Flask wrapped by a WSGI Server. dispatcher = PathInfoDispatcher({'/': flask_instance}) server = WSGIServer( (self._listening_address, self._listening_port), dispatcher) try: server.start() # server.block except KeyboardInterrupt: server.stop() else: raise RuntimeError("Invalid runtime mode was selected.")
def start_server(options): """ Start CherryPy server """ if options['daemonize'] and options['server_user'] and options['server_group']: # ensure the that the daemon runs as specified user change_uid_gid(options['server_user'], options['server_group']) try: from cheroot.wsgi import Server as Server except ImportError: from cherrypy.wsgiserver import CherryPyWSGIServer as Server from django.core.handlers.wsgi import WSGIHandler server = Server( (options['host'], int(options['port'])), WSGIHandler(), int(options['threads']), options['server_name'] ) if options['ssl_certificate'] and options['ssl_private_key']: server.ssl_certificate = options['ssl_certificate'] server.ssl_private_key = options['ssl_private_key'] try: server.start() except KeyboardInterrupt: server.stop()
def start_ui(url, port, interpreter, quiet, language): openurl = "localhost" if url == "0.0.0.0" else url if not quiet: print("Booting CherryPy server...") d = PathInfoDispatcher({'/': create_app(interpreter, language)}) server = WSGIServer((url, port), d) try: p = multiprocessing.Process(target=delayed_browser_open, args=(openurl, port)) p.start() if not quiet: print("Hosting at http://" + openurl + ":" + str(port) + "/#loaded") server.start() except KeyboardInterrupt: if not quiet: print("Stopping CherryPy server...") server.stop() if not quiet: print("Stopped")
def start_ui(url, port, interpreter, quiet): openurl = "localhost" if url == "0.0.0.0" else url if not quiet: print("Initializing CherryPy server...") os.environ["FLASK_APP"] = "satyrnUI.satyrnUI" os.environ["FLASK_ENV"] = "production" d = PathInfoDispatcher({'/': create_app(interpreter)}) server = WSGIServer((url, port), d) try: p = multiprocessing.Process(target=delayed_browser_open, args=(openurl, port)) p.start() if not quiet: print("Hosting at http://" + openurl + ":" + str(port) + "/#loaded") server.start() except KeyboardInterrupt: if not quiet: print("Stopping CherryPy server...") server.stop() if not quiet: print("Stopped")
def main(argv=sys.argv[1:]) -> int: """main entry point for the autotradeweb server""" parser = get_parser() args = parser.parse_args(argv) init_logging(args, "autotradeweb.log") # monkey patch courtesy of # https://github.com/noirbizarre/flask-restplus/issues/54 # so that /swagger.json is served over https if not args.disable_https: @property def specs_url(self): """Monkey patch for HTTPS""" return url_for(self.endpoint("specs"), _external=True, _scheme="https") Api.specs_url = specs_url __log__.info("starting server: host: {} port: {}".format(args.host, args.port)) APP.config["SQLALCHEMY_DATABASE_URI"] = args.database if args.debug: APP.run(host=args.host, port=args.port, debug=True) else: path_info_dispatcher = PathInfoDispatcher({"/": APP}) # See SRS: S.8.R.4 server = WSGIServer((args.host, args.port), path_info_dispatcher) try: server.start() except KeyboardInterrupt: __log__.info("stopping server: KeyboardInterrupt detected") server.stop() return 0 except Exception: __log__.exception("stopping server: unexpected exception") raise
def wsgi_serve( wsgi_handler: Callable, host: str = "127.0.0.1", port: int = 80, workers: int = 1, ) -> None: wsgi_server = Server((host, port), wsgi_handler, numthreads=workers) wsgi_server.start()
def initiate(): log_main.info('Iniciando a API versão: {}'.format(app_version)) signal.signal(signal.SIGTERM, finalize) signal.signal(signal.SIGINT, finalize) global token, database, sms token = conf.get('Auth', 'Token', fallback='14acd1c3b2f50c1e7354668f7d0b4057') ttvToken = open( os.path.join(workdir, conf.get('Auth', 'TokenTTV', fallback=False)), 'r') sms = SMS(ttvToken.readline()) ttvToken.close() log_main.warning('Iniciando conexão com banco de dados ...') try: db = os.path.join(workdir, conf.get('Database', 'Database', fallback='data.db')) database = Database(db) except Exception as e: log_main.exception( 'Erro ao iniciar a conexão com o banco de dados: [{}]'.format(e)) _port = conf.getint('Flask', 'Port', fallback=8860) _host = conf.get('Flask', 'Host', fallback='0.0.0.0') _threads = conf.getint('Flask', 'Threads', fallback=100) _ssl_cert = os.path.join(workdir, 'SSL', conf.get('Flask', 'SSL_Cert', fallback='')) _ssl_key = os.path.join(workdir, 'SSL', conf.get('Flask', 'SSL_Key', fallback='')) try: _ssl_enabled = os.path.isfile(_ssl_cert) and os.path.isfile(_ssl_key) except Exception: _ssl_enabled = False if len(sys.argv) > 1: if sys.argv[1] in ('-v', '--version'): print('API') print('Versão: {}'.format(app_version)) sys.exit(0) elif sys.argv[1] in ('-d', '--debug'): app.run(host=_host, port=_port, threaded=True, debug=True) else: print('ERRO | Parâmetro desconhecido: {}'.format(sys.argv)) sys.exit(2) else: global server server = WSGIServer(bind_addr=(_host, _port), wsgi_app=app, numthreads=_threads) if _ssl_enabled: server.ssl_adapter = BuiltinSSLAdapter(_ssl_cert, _ssl_key) log_main.warning('Iniciando flask ...') server.start()
def launch_server(host, port, app, **kwargs): """Use cheroot WSGI server, a multithreaded scallable server.""" server = Server((host, port), app, **kwargs) logging.info("Starting server, listening on port %s", port) try: server.start() except KeyboardInterrupt: server.stop()
def start_rest_service(port, num_threads, ovms_port): available_models = get_available_models() dispatcher = PathInfoDispatcher( {'/': create_dispatcher(available_models, ovms_port)}) server = WSGIServer(('0.0.0.0', port), dispatcher, numthreads=num_threads) logger.info(f"AMS service will start listening on port {port}") try: server.start() except KeyboardInterrupt: server.stop()
def run(self, handler): cert = SSL_CERT #cert_chain = SSL_CERT_CHAIN privkey = SSL_PRIVKEY server = WSGIServer((self.host, self.port), handler) server.ssl_adapter = SecuredSSLServer(cert, privkey) #, cert_chain) try: server.start() finally: server.stop()
def _flaskthread(self): if self.debug: self.app.run(host=self.host, port=self.port, debug=self.debug) else: wsgi_server = WSGIServer(bind_addr=("0.0.0.0", self.wsgi_port), wsgi_app=self.app, numthreads=100) try: wsgi_server.start() except KeyboardInterrupt: wsgi_server.stop()
def run(self, handler): from cheroot.wsgi import Server self.options['bind_addr'] = (self.host, self.port) self.options['wsgi_app'] = handler server = Server(**self.options) try: server.start() finally: server.stop()
class Controller (object): def listen(self): print("listening") self.server = WSGIServer(('0.0.0.0', 8000), webapp) # run(webapp, server=self.server) # run(webapp, server='bjoern', port=8000) self.server.start() def shutdown(self): self.server.stop() print("done listening")
def start_web_rest_server(models, rest_port): d = PathInfoDispatcher({'/': create_rest_api(models)}) server = WSGIServer(('0.0.0.0', rest_port), d, numthreads=1, request_queue_size=50) try: server.start() except KeyboardInterrupt: server.stop()
def run(self, handler): try: from cheroot.wsgi import Server as WSGIServer except ImportError: from cherrypy.wsgiserver import CherryPyWSGIServer as WSGIServer server = WSGIServer((self.host, self.port), handler) try: server.start() finally: server.stop()
def run(self, handler): from cheroot.wsgi import Server as WSGIServer from cheroot.ssl.pyopenssl import pyOpenSSLAdapter server = WSGIServer((self.host, self.port), handler) server.ssl_adapter = pyOpenSSLAdapter( certificate=SolUtils.AppConfig().get('solserver_certificate'), private_key=SolUtils.AppConfig().get('solserver_private_key'), ) try: server.start() log.info("Server started") finally: server.stop()
def main(): args = get_args() app = create_app(args.output) d = PathInfoDispatcher({"/": app}) server = WSGIServer((args.netmask, args.port), d) try: print(f"Logging location set to: {args.output}") print(f"Listening on {args.netmask}:{args.port}....") server.start() except KeyboardInterrupt: print("Exiting....") sys.exit(0)
def start_web_rest_server(models, rest_port, num_threads): d = PathInfoDispatcher({'/': create_rest_api(models)}) server = WSGIServer(('0.0.0.0', rest_port), d, numthreads=num_threads, request_queue_size=GLOBAL_CONFIG[ 'rest_requests_queue_size']) logger.info("REST server listens on port {port} and will be " "serving models: {models}".format(port=rest_port, models=list(models.keys()))) try: server.start() except KeyboardInterrupt: server.stop()
class CherryPyServer(ServerAdapter): def run(self, handler): try: from cheroot.wsgi import Server as CherryPyWSGIServer except ImportError: from cherrypy.wsgiserver import CherryPyWSGIServer self.server = CherryPyWSGIServer((self.host, self.port), handler) try: self.server.start() finally: self.server.stop() def stop(self): if hasattr(self, 'server'): self.server.stop()
def start_server(config): from cheroot.wsgi import Server as WSGIServer hostname = config['server_host']['host'] port = int(config['server_host']['port']) scheme = config['server_host']['scheme'] app = load_app() server = WSGIServer((hostname, port), app) try: LOGGER.debug('starting Cheroot at %s://%s:%s', scheme, hostname, port) std_error_message("Starting Cheroot at %s://%s:%s" % (scheme, hostname, port)) server.start() except KeyboardInterrupt: server.stop() sys.exit(0)
def run(self): logger.info( f"HTTP server listens on http://{self.host}:{self.port}{self.endpoint}" ) if self.agent: self.agent.server_status.starttime = datetime.now() if self.debug: self.app.run(host=self.host, port=self.port, debug=self.debug) else: wsgi_server = WSGIServer(bind_addr=("0.0.0.0", self.wsgi_port), wsgi_app=self.app, numthreads=100) try: wsgi_server.start() except KeyboardInterrupt: wsgi_server.stop()
def run(self, handler): """ Runs a CherryPy Server using the SSL certificate. """ from cheroot.wsgi import Server as CherryPyWSGIServer from cheroot.ssl.builtin import BuiltinSSLAdapter server = CherryPyWSGIServer((self.host, self.port), handler) server.ssl_adapter = BuiltinSSLAdapter( certificate=get_ssl_certificate(), private_key=get_ssl_private_key(), certificate_chain=get_ssl_certificate_chain() if get_ssl_certificate_chain() != "" else None) try: server.start() except Exception as ex: LOG.error('Unable to start SSL server: %s' % ex) server.stop()
def run(self, handler): """ Run server """ try: from cheroot.wsgi import Server as WSGIServer except ImportError: from cherrypy.wsgiserver import CherryPyWSGIServer as WSGIServer global server # server = wsgiserver.CherryPyWSGIServer((self.host, self.port), handler) server = WSGIServer((self.host, self.port), handler) # cert = 'server.pem' # certificate path # server.ssl_certificate = cert # server.ssl_private_key = cert try: server.start() finally: server.stop()
class HTTPServer: def __init__(self, port=8090): self.mappings = {} self.port = port self.server = CherryPyWSGIServer(("0.0.0.0", port), self, server_name="localhost") self.started = False self.t = threading.Thread(target=self._start) self.t.start() time.sleep(0.1) def _start(self): try: self.server.start() except Exception as e: print('ERROR: failed to start server', str(e)) def stop(self): self.server.stop() self.t.join() def request(self, path, method='GET', query=None): query = query or {} response = Respose() if isinstance(query, dict): query = urllib.parse.urlencode(query) self.mappings[path, method, query] = response return response def __call__(self, environ, start_response): _method = environ.get('REQUEST_METHOD', 'GET') _path = environ.get('PATH_INFO') for (path, method, query_string), response in self.mappings.items(): if _path == path and _method == method: return response(start_response) return Respose()(start_response)
def run(self, handler): # pragma: no cover from cheroot.wsgi import Server as WSGIServer self.options['bind_addr'] = (self.host, self.port) self.options['wsgi_app'] = handler certfile = self.options.get('certfile') if certfile: del self.options['certfile'] keyfile = self.options.get('keyfile') if keyfile: del self.options['keyfile'] server = WSGIServer(**self.options) if certfile: server.ssl_certificate = certfile if keyfile: server.ssl_private_key = keyfile try: server.start() finally: server.stop()
def main(): clear_screen() print_logo() with AdbInstaller() as installer: installer.install() AdbWrapper().disconnect_all() success("Açık kalan ADB bağlantıları kapatıldı!") web.api_key = "Girilmedi!" success("Sunucu başlatılıyor!") try: http_server = WSGIServer(("127.0.0.1", 5000), PathInfoDispatcher({'/': website_app})) success("Sunucu başlatıldı!") success("Arayüz adresi: http://localhost:5000") http_server.start() except KeyboardInterrupt: clear_screen() success("Kapatılıyor!") _exit(0)
def run_server(self, port=None): log.info("home_dir %s", config.get('DEFAULT', 'home_dir')) log.info("hydra_base_dir %s", config.get('DEFAULT', 'hydra_base_dir')) log.info("common_app_data_folder %s", config.get('DEFAULT', 'common_app_data_folder')) log.info("win_common_documents %s", config.get('DEFAULT', 'win_common_documents')) log.info("sqlite url %s", config.get('mysqld', 'url')) log.info("layout_xsd_path %s", config.get('hydra_server', 'layout_xsd_path')) log.info("default_directory %s", config.get('plugin', 'default_directory')) log.info("result_file %s", config.get('plugin', 'result_file')) log.info("plugin_xsd_path %s", config.get('plugin', 'plugin_xsd_path')) log.info("log_config_path %s", config.get('logging_conf', 'log_config_path')) if port is None: port = config.getint('hydra_server', 'port', 8080) domain = config.get('hydra_server', 'domain', '127.0.0.1') check_port_available(domain, port) spyne.const.xml_ns.DEFAULT_NS = 'soap_server.hydra_complexmodels' cp_wsgi_application = Server((domain, port), application, numthreads=10) log.info("listening to http://%s:%s", domain, port) log.info("wsdl is at: http://%s:%s/soap/?wsdl", domain, port) try: cp_wsgi_application.start() except KeyboardInterrupt: cp_wsgi_application.stop()
if sucess_login: session['logged_in'] = True logger.info("{ip} successfully looged in".format(ip=ip)) flash('You were successfully logged in!') else: logger.warning( "{ip} attempted to log in with wrong password".format(ip=ip)) flash('wrong password!') return index() ################################################## # END API part ################################################## if __name__ == "__main__": log_manager = LogManager() logger = log_manager.logger logger.info('Running Flask Server on http://localhost:{port}'.format( port=os.environ.get("SERVER_PORT"))) app.secret_key = os.urandom(12) server = WSGIServer(('0.0.0.0', int(os.environ.get("SERVER_PORT"))), app, numthreads=int(os.environ.get("SERVER_NUM_THREADS"))) try: server.start() except KeyboardInterrupt: logger.critical("KeyboardInterrupt")
sign_alg = None digest_alg = None try: sign_alg = CONFIG.SIGN_ALG except AttributeError: pass try: digest_alg = CONFIG.DIGEST_ALG except AttributeError: pass ds.DefaultSignature(sign_alg, digest_alg) SRV = WSGIServer((HOST, PORT), application) _https = "" if CONFIG.HTTPS: https = "using HTTPS" # SRV.ssl_adapter = ssl_pyopenssl.pyOpenSSLAdapter( # config.SERVER_CERT, config.SERVER_KEY, config.CERT_CHAIN) SRV.ssl_adapter = BuiltinSSLAdapter(CONFIG.SERVER_CERT, CONFIG.SERVER_KEY, CONFIG.CERT_CHAIN) logger.info("Server starting") print("IDP listening on %s:%s%s" % (HOST, PORT, _https)) try: SRV.start() except KeyboardInterrupt: SRV.stop()
POLICY = service_conf.POLICY add_urls() sign_alg = None digest_alg = None try: sign_alg = service_conf.SIGN_ALG except: pass try: digest_alg = service_conf.DIGEST_ALG except: pass ds.DefaultSignature(sign_alg, digest_alg) SRV = WSGIServer((HOST, PORT), ToBytesMiddleware(application)) _https = "" if service_conf.HTTPS: SRV.ssl_adapter = pyopenssl.pyOpenSSLAdapter( SERVER_CERT, SERVER_KEY, CERT_CHAIN ) _https = " using SSL/TLS" logger.info("Server starting") print("SP listening on %s:%s%s" % (HOST, PORT, _https)) try: SRV.start() except KeyboardInterrupt: SRV.stop()
def cherrypy_server_runner( app, global_conf=None, host='127.0.0.1', port=None, ssl_pem=None, protocol_version=None, numthreads=None, server_name=None, max=None, request_queue_size=None, timeout=None ): # pragma: no cover """ Entry point for CherryPy's WSGI server Serves the specified WSGI app via CherryPyWSGIServer. ``app`` The WSGI 'application callable'; multiple WSGI applications may be passed as (script_name, callable) pairs. ``host`` This is the ipaddress to bind to (or a hostname if your nameserver is properly configured). This defaults to 127.0.0.1, which is not a public interface. ``port`` The port to run on, defaults to 8080 for HTTP, or 4443 for HTTPS. This can be a string or an integer value. ``ssl_pem`` This an optional SSL certificate file (via OpenSSL) You can generate a self-signed test PEM certificate file as follows: $ openssl genrsa 1024 > host.key $ chmod 400 host.key $ openssl req -new -x509 -nodes -sha1 -days 365 \\ -key host.key > host.cert $ cat host.cert host.key > host.pem $ chmod 400 host.pem ``protocol_version`` The protocol used by the server, by default ``HTTP/1.1``. ``numthreads`` The number of worker threads to create. ``server_name`` The string to set for WSGI's SERVER_NAME environ entry. ``max`` The maximum number of queued requests. (defaults to -1 = no limit). ``request_queue_size`` The 'backlog' argument to socket.listen(); specifies the maximum number of queued connections. ``timeout`` The timeout in seconds for accepted connections. """ is_ssl = False if ssl_pem: port = port or 4443 is_ssl = True if not port: if ':' in host: host, port = host.split(':', 1) else: port = 8080 bind_addr = (host, int(port)) kwargs = {} for var_name in ('numthreads', 'max', 'request_queue_size', 'timeout'): var = locals()[var_name] if var is not None: kwargs[var_name] = int(var) try: from cheroot.wsgi import Server as WSGIServer except ImportError: from cherrypy.wsgiserver import CherryPyWSGIServer as WSGIServer server = WSGIServer(bind_addr, app, server_name=server_name, **kwargs) if ssl_pem is not None: if PY2: server.ssl_certificate = server.ssl_private_key = ssl_pem else: # creates wsgiserver.ssl_builtin as side-effect try: from cheroot.server import get_ssl_adapter_class from cheroot.ssl.builtin import BuiltinSSLAdapter except ImportError: from cherrypy.wsgiserver import get_ssl_adapter_class from cherrypy.wsgiserver.ssl_builtin import BuiltinSSLAdapter get_ssl_adapter_class() server.ssl_adapter = BuiltinSSLAdapter(ssl_pem, ssl_pem) if protocol_version: server.protocol = protocol_version try: protocol = is_ssl and 'https' or 'http' if host == '0.0.0.0': print('serving on 0.0.0.0:%s view at %s://127.0.0.1:%s' % (port, protocol, port)) else: print('serving on %s://%s:%s' % (protocol, host, port)) server.start() except (KeyboardInterrupt, SystemExit): server.stop() return server
def cherrypy(app, address, **options): from cheroot.wsgi import Server as WSGIServer server = WSGIServer(address, app) server.start()