def gevent_run(app, address, port, debugger=False, reloader=False): from gevent.wsgi import WSGIServer from werkzeug.debug import DebuggedApplication import gevent.monkey gevent.monkey.patch_all() run_app = app if debugger: run_app = DebuggedApplication(app) def run_server(): import logging from gevent import version_info logger = logging.getLogger('pydirl') logger.info('Listening on http://{}:{}/'.format(address, port)) server_params = dict() # starting from gevent version 1.1b1 we can pass custom logger to gevent if version_info[:2] >= (1, 1): server_params['log'] = logger http_server = WSGIServer((address, port), run_app, **server_params) http_server.serve_forever() if reloader: from werkzeug._reloader import run_with_reloader run_with_reloader(run_server) else: run_server()
def run(): import argparse parser = argparse.ArgumentParser(description='Phovea Server') parser.add_argument('--use_reloader', action='store_true', help='whether to automatically reload the server') parser.add_argument('--env', default=cc.get('env'), help='environment mode (dev or prod)') # parse before to enable correct plugin discovery args = parser.parse_known_args()[0] if args.env.startswith('dev'): enable_dev_mode() else: enable_prod_mode() default_command = _resolve_commands(parser) if default_command is not None: set_default_subparser(parser, default_command) args = parser.parse_args() _set_runtime_infos(args) main = args.launcher(args) if args.use_reloader: _log.info('start using reloader...') from werkzeug._reloader import run_with_reloader run_with_reloader(main, extra_files=_config_files()) else: _log.info('start...') main()
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(): from gevent import version_info logger = app._logger port = int(app.config.get('PORT', 5000)) address = app.config.get('ADDRESS', '') logger.info('Listening on http://{}:{}/'.format(address or '0.0.0.0', port)) server_params = dict() #starting from gevent version 1.1b1 we can pass custom logger to gevent if version_info[:2] >= (1,1): server_params['log'] = logger http_server = WSGIServer((address, port), run_app, **server_params) http_server.serve_forever() if app.config['DEBUG']: from werkzeug._reloader import run_with_reloader run_with_reloader(run_server) else: run_server()
def gevent_run(app, address, port, debugger=False, reloader=False): from gevent.wsgi import WSGIServer from werkzeug.debug import DebuggedApplication import gevent.monkey gevent.monkey.patch_all() run_app = app if debugger: run_app = DebuggedApplication(app) def run_server(): import logging from gevent import version_info logger = logging.getLogger('pydirl') logger.info('Listening on http://{}:{}/'.format(address, port)) server_params = dict() # starting from gevent version 1.1b1 we can pass custom logger to gevent if version_info[:2] >= (1, 1): server_params['log'] = logger http_server = WSGIServer((address, port), run_app, **server_params) http_server.serve_forever() if reloader: from werkzeug._reloader import run_with_reloader run_with_reloader(run_server) else: run_server()
def run_simple( hostname, port, application, use_reloader=False, use_debugger=False, use_evalex=True, extra_files=None, reloader_interval=1, reloader_type="auto", threaded=False, processes=1, request_handler=None, static_files=None, passthrough_errors=False, ssl_context=None, ): if use_debugger: from werkzeug.debug import DebuggedApplication application = DebuggedApplication(application, use_evalex) if static_files: from werkzeug.wsgi import SharedDataMiddleware application = SharedDataMiddleware(application, static_files) def inner(): # Override here make_server( hostname, port, application, threaded, processes, request_handler, passthrough_errors, ssl_context ).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 quit_msg = "(Press CTRL+C to quit)" _log( "info", " * Running on %s://%s:%d/ %s", ssl_context is None and "http" or "https", display_hostname, port, quit_msg, ) if use_reloader: # Create and destroy a socket so that any exceptions are raised before # we spawn a separate Python interpreter and lose this ability. address_family = select_ip_version(hostname, port) test_socket = socket.socket(address_family, socket.SOCK_STREAM) test_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) test_socket.bind((hostname, port)) test_socket.close() from werkzeug._reloader import run_with_reloader run_with_reloader(inner, extra_files, reloader_interval, reloader_type) else: inner()
def serve(address="0.0.0.0", port=8000, config=configfile, source='default'): from werkzeug._reloader import run_with_reloader from werkzeug.serving import run_simple from threading import Thread def inner(): cfg = load_config(config, source) Thread(target=lambda: watch(cfg), daemon=True).start() run_simple(address, port, cfg.application, use_debugger=True) run_with_reloader(inner)
def main(): # Command-line entry point for setup.py install/develop command = get_command() shell = get_shell() files = get_files() run_with_reloader( lambda: subprocess.call( command, shell=True, executable=shell), extra_files=files)
def runserver(host, port, **kwargs): app = create_app(**kwargs) def serve(): from paste.translogger import TransLogger wsgi = TransLogger(app.wsgi_app) waitress.serve(wsgi, host=host, port=port) if app.config.get('RELOADER'): from werkzeug._reloader import run_with_reloader run_with_reloader(serve) else: serve()
def runserver(host, port, **kwargs): app = create_app(**kwargs) def serve(): from paste.translogger import TransLogger wsgi = TransLogger(app.wsgi_app) waitress.serve(wsgi, host=host, port=port) if app.config.get('RELOADER'): from werkzeug._reloader import run_with_reloader run_with_reloader(serve) else: serve()
def run(rpc_class, host='0.0.0.0', port=4242, autoreload=True): """ Start a rpc server :param rpc_class: The rpc service module :param host: The host to bind to, for example ``'localhost'`` :param port: The port for the server. eg: ``4242`` :param autoreload: should the server automatically restart the python process if modules were changed? """ main_func = partial(run_server, rpc_class, host, port) if autoreload: run_with_reloader(main_func) else: main_func()
def run_simple(hostname, port, application, use_reloader=False, use_debugger=False, use_evalex=True, extra_files=None, reloader_interval=1, reloader_type='auto', threaded=False, processes=1, request_handler=None, static_files=None, passthrough_errors=False, ssl_context=None): if use_debugger: from werkzeug.debug import DebuggedApplication application = DebuggedApplication(application, use_evalex) if static_files: from werkzeug.wsgi import SharedDataMiddleware application = SharedDataMiddleware(application, static_files) def inner(): # Override here make_server(hostname, port, application, threaded, processes, request_handler, passthrough_errors, ssl_context).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 quit_msg = '(Press CTRL+C to quit)' _log('info', ' * Running on %s://%s:%d/ %s', ssl_context is None and 'http' or 'https', display_hostname, port, quit_msg) if use_reloader: # Create and destroy a socket so that any exceptions are raised before # we spawn a separate Python interpreter and lose this ability. address_family = select_ip_version(hostname, port) test_socket = socket.socket(address_family, socket.SOCK_STREAM) test_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) test_socket.bind((hostname, port)) test_socket.close() from werkzeug._reloader import run_with_reloader run_with_reloader(inner, extra_files, reloader_interval, reloader_type) else: inner()
def main(): parser = configargparse.ArgumentParser("mediaTUM start.py") parser.add_argument("-b", "--bind", default=None, help="hostname / IP to bind to, default: see config file") parser.add_argument("-p", "--http_port", default=None, help="HTTP port to use, default: see config file") parser.add_argument("-r", "--reload", action="store_true", default=False, help="reload when code or config file changes, default false") parser.add_argument("-s", "--stackdump", action="store_true", default=True, help="write stackdumps to temp dir {} on SIGQUIT, default true".format(SYSTEM_TMP_DIR)) parser.add_argument("--force-test-db", action="store_true", default=False, help="create / use database server with default database for testing (overrides configured db connection)") parser.add_argument("-l", "--loglevel", help="root loglevel, sensible values: DEBUG, INFO, WARN") parser.add_argument("-m", "--automigrate", action="store_true", default=False, help="run automatic database schema upgrades on startup") parser.add_argument( "--redis-sessions", action="store_true", default=False, help="EXPERIMENTAL: save sessions to redis, making them persistent, requires redis-collections and a redis server on localhost!") args = parser.parse_args() print("start.py args:", args) def signal_handler_usr1(signum, stack): import utils.log utils.log.reopen_log(None, None) import signal signal.signal(signal.SIGUSR1, signal_handler_usr1) if args.stackdump: stackdump_setup() if args.reload: # don't use this in production! maybe_config_filepath = config.get_config_filepath() extra_files = [maybe_config_filepath] if maybe_config_filepath else [] def main_wrapper(): run(args.bind, args.http_port, args.redis_sessions, args.force_test_db, args.loglevel, args.automigrate) run_with_reloader(main_wrapper, extra_files) else: run(args.bind, args.http_port, args.redis_sessions, args.force_test_db, args.loglevel, args.automigrate)
def main(): parser = configargparse.ArgumentParser("mediaTUM start.py") parser.add_argument("-b", "--bind", default=None, help="hostname / IP to bind to, default: see config file") parser.add_argument("-p", "--http_port", default=None, help="HTTP port to use, default: see config file") parser.add_argument("-r", "--reload", action="store_true", default=False, help="reload when code or config file changes, default false") parser.add_argument("-s", "--stackdump", action="store_true", default=True, help="write stackdumps to temp dir {} on SIGQUIT, default true".format(SYSTEM_TMP_DIR)) parser.add_argument("--force-test-db", action="store_true", default=False, help="create / use database server with default database for testing (overrides configured db connection)") parser.add_argument("-l", "--loglevel", help="root loglevel, sensible values: DEBUG, INFO, WARN") parser.add_argument("-m", "--automigrate", action="store_true", default=False, help="run automatic database schema upgrades on startup") parser.add_argument( "--redis-sessions", action="store_true", default=False, help="EXPERIMENTAL: save sessions to redis, making them persistent, requires redis-collections and a redis server on localhost!") args = parser.parse_args() print("start.py args:", args) def signal_handler_usr1(signum, stack): import utils.log utils.log.reopen_log(None, None) import signal signal.signal(signal.SIGUSR1, signal_handler_usr1) if args.stackdump: stackdump_setup() if args.reload: # don't use this in production! maybe_config_filepath = config.get_config_filepath() extra_files = [maybe_config_filepath] if maybe_config_filepath else [] def main_wrapper(): run(args.bind, args.http_port, args.redis_sessions, args.force_test_db, args.loglevel, args.automigrate) run_with_reloader(main_wrapper, extra_files) else: run(args.bind, args.http_port, args.redis_sessions, args.force_test_db, args.loglevel, args.automigrate)
def runserver(host, port, **kwargs): """ Runs the GitLFS Server (WIP) Arguments: host [str] -- the host for the server port [int] -- the port for the server """ app = create_app(**kwargs) if app.config.get('HOST'): host = app.config.get('HOST') def serve(): from paste.translogger import TransLogger wsgi = TransLogger(app.wsgi_app) waitress.serve(wsgi, host=host, port=port) if app.config.get('RELOADER'): from werkzeug._reloader import run_with_reloader run_with_reloader(serve) else: serve()
def cmd_run(host, port, debugger, use_reloader): """Run a development server. This is a replacement for the default "run" command from flask CLI. Will use WSGIServer and WebSocketHandler from gevent to properly handle websocket connections. Note that reloading uses an undocumented API from werkzeug, that might stop working in the future. Another option would be to use gunicorn, but keep in mind it only works on Unix-like systems:: gunicorn -k flask_sockets.worker app.dev:app \ --reload --bind localhost:5000 """ from werkzeug._reloader import run_with_reloader def _run_development_server(): from gevent import pywsgi from geventwebsocket.handler import WebSocketHandler app = create_app() app.debug = debugger server = pywsgi.WSGIServer( (host, port), app, handler_class=WebSocketHandler, log=logger ) server.serve_forever() if use_reloader: # WARNING: This is an undocumented API return run_with_reloader(_run_development_server) return _run_development_server()
def run_simple(hostname, port, application, use_reloader=False, use_debugger=False, use_evalex=True, extra_files=None, reloader_interval=1, reloader_type='auto', threaded=False, processes=1, request_handler=None, static_files=None, passthrough_errors=False, ssl_context=None): """Start a WSGI application. Optional features include a reloader, multithreading and fork support. This function has a command-line interface too:: python -m werkzeug.serving --help .. versionadded:: 0.5 `static_files` was added to simplify serving of static files as well as `passthrough_errors`. .. versionadded:: 0.6 support for SSL was added. .. versionadded:: 0.8 Added support for automatically loading a SSL context from certificate file and private key. .. versionadded:: 0.9 Added command-line interface. .. versionadded:: 0.10 Improved the reloader and added support for changing the backend through the `reloader_type` parameter. See :ref:`reloader` for more information. .. versionchanged:: 0.15 Bind to a Unix socket by passing a path that starts with ``unix://`` as the ``hostname``. :param hostname: The host to bind to, for example ``'localhost'``. If the value is a path that starts with ``unix://`` it will bind to a Unix socket instead of a TCP socket.. :param port: The port for the server. eg: ``8080`` :param application: the WSGI application to execute :param use_reloader: should the server automatically restart the python process if modules were changed? :param use_debugger: should the werkzeug debugging system be used? :param use_evalex: should the exception evaluation feature be enabled? :param extra_files: a list of files the reloader should watch additionally to the modules. For example configuration files. :param reloader_interval: the interval for the reloader in seconds. :param reloader_type: the type of reloader to use. The default is auto detection. Valid values are ``'stat'`` and ``'watchdog'``. See :ref:`reloader` for more information. :param threaded: should the process handle each request in a separate thread? :param processes: if greater than 1 then handle each request in a new process up to this maximum number of concurrent processes. :param request_handler: optional parameter that can be used to replace the default one. You can use this to replace it with a different :class:`~BaseHTTPServer.BaseHTTPRequestHandler` subclass. :param static_files: a list or dict of paths for static files. This works exactly like :class:`SharedDataMiddleware`, it's actually just wrapping the application in that middleware before serving. :param passthrough_errors: set this to `True` to disable the error catching. This means that the server will die on errors but it can be useful to hook debuggers in (pdb etc.) :param ssl_context: an SSL context for the connection. Either an :class:`ssl.SSLContext`, a tuple in the form ``(cert_file, pkey_file)``, the string ``'adhoc'`` if the server should automatically create one, or ``None`` to disable SSL (which is the default). """ if not isinstance(port, int): raise TypeError('port must be an integer') if use_debugger: from werkzeug.debug import DebuggedApplication application = DebuggedApplication(application, use_evalex) if static_files: from werkzeug.wsgi import SharedDataMiddleware application = SharedDataMiddleware(application, static_files) def log_startup(sock): display_hostname = hostname not in ('', '*') and hostname or 'localhost' quit_msg = '(Press CTRL+C to quit)' if sock.family is socket.AF_UNIX: _log('info', ' * Running on %s %s', display_hostname, quit_msg) else: if ':' in display_hostname: display_hostname = '[%s]' % display_hostname port = sock.getsockname()[1] _log('info', ' * Running on %s://%s:%d/ %s', ssl_context is None and 'http' or 'https', display_hostname, port, quit_msg) def inner(): try: fd = int(os.environ['WERKZEUG_SERVER_FD']) except (LookupError, ValueError): fd = None srv = make_server(hostname, port, application, threaded, processes, request_handler, passthrough_errors, ssl_context, fd=fd) if fd is None: log_startup(srv.socket) srv.serve_forever() if use_reloader: # If we're not running already in the subprocess that is the # reloader we want to open up a socket early to make sure the # port is actually available. if os.environ.get('WERKZEUG_RUN_MAIN') != 'true': if port == 0 and not can_open_by_fd: raise ValueError('Cannot bind to a random port with enabled ' 'reloader if the Python interpreter does ' 'not support socket opening by fd.') # Create and destroy a socket so that any exceptions are # raised before we spawn a separate Python interpreter and # lose this ability. address_family = select_address_family(hostname, port) server_address = get_sockaddr(hostname, port, address_family) s = socket.socket(address_family, socket.SOCK_STREAM) s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) s.bind(server_address) if hasattr(s, 'set_inheritable'): s.set_inheritable(True) # If we can open the socket by file descriptor, then we can just # reuse this one and our socket will survive the restarts. if can_open_by_fd: os.environ['WERKZEUG_SERVER_FD'] = str(s.fileno()) s.listen(LISTEN_QUEUE) log_startup(s) else: s.close() if address_family is socket.AF_UNIX: _log('info', "Unlinking %s" % server_address) os.unlink(server_address) # Do not use relative imports, otherwise "python -m werkzeug.serving" # breaks. from werkzeug._reloader import run_with_reloader run_with_reloader(inner, extra_files, reloader_interval, reloader_type) else: inner()
] b = px + [ ord(c) for c in '123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklnm\n' ] # b = [0x31, 0x32, 0x33, 0x0A, 0x1D, 0x4C, 0xE0, 0x00, 0x31, 0x32, 0x33, 0x0A] b = bytes(px) + pt.get_data()[2:] for i in b: print(hex(i)) p._raw(bytes(b)) p.close() def do_usb_test2(): from escpos.printer import Usb # p = Usb(0x6868, 0x0500, in_ep=0x84, out_ep=0x3) # p = Usb(0x2207, 0x0011, in_ep=0x02, out_ep=0x01) # p._raw(b'\x1b\x42\x02\x01') # p.close() if __name__ == '__main__': # do_table_test() do_all_test() # do_usb_test() # do_usb_test() exit() from werkzeug._reloader import run_with_reloader run_with_reloader(lambda: do_table_test())
def run_simple(hostname, port, application, use_reloader=False, use_debugger=False, use_evalex=True, extra_files=None, reloader_interval=1, reloader_type='auto', threaded=False, processes=1, request_handler=None, static_files=None, passthrough_errors=False, ssl_context=None): """Start a WSGI application. Optional features include a reloader, multithreading and fork support. This function has a command-line interface too:: python -m werkzeug.serving --help .. versionadded:: 0.5 `static_files` was added to simplify serving of static files as well as `passthrough_errors`. .. versionadded:: 0.6 support for SSL was added. .. versionadded:: 0.8 Added support for automatically loading a SSL context from certificate file and private key. .. versionadded:: 0.9 Added command-line interface. .. versionadded:: 0.10 Improved the reloader and added support for changing the backend through the `reloader_type` parameter. See :ref:`reloader` for more information. :param hostname: The host for the application. eg: ``'localhost'`` :param port: The port for the server. eg: ``8080`` :param application: the WSGI application to execute :param use_reloader: should the server automatically restart the python process if modules were changed? :param use_debugger: should the werkzeug debugging system be used? :param use_evalex: should the exception evaluation feature be enabled? :param extra_files: a list of files the reloader should watch additionally to the modules. For example configuration files. :param reloader_interval: the interval for the reloader in seconds. :param reloader_type: the type of reloader to use. The default is auto detection. Valid values are ``'stat'`` and ``'watchdog'``. See :ref:`reloader` for more information. :param threaded: should the process handle each request in a separate thread? :param processes: if greater than 1 then handle each request in a new process up to this maximum number of concurrent processes. :param request_handler: optional parameter that can be used to replace the default one. You can use this to replace it with a different :class:`~BaseHTTPServer.BaseHTTPRequestHandler` subclass. :param static_files: a dict of paths for static files. This works exactly like :class:`SharedDataMiddleware`, it's actually just wrapping the application in that middleware before serving. :param passthrough_errors: set this to `True` to disable the error catching. This means that the server will die on errors but it can be useful to hook debuggers in (pdb etc.) :param ssl_context: an SSL context for the connection. Either an :class:`ssl.SSLContext`, a tuple in the form ``(cert_file, pkey_file)``, the string ``'adhoc'`` if the server should automatically create one, or ``None`` to disable SSL (which is the default). """ if use_debugger: from werkzeug.debug import DebuggedApplication application = DebuggedApplication(application, use_evalex) if static_files: from werkzeug.wsgi import SharedDataMiddleware application = SharedDataMiddleware(application, static_files) def log_startup(sock): display_hostname = hostname not in ('', '*') and hostname or 'localhost' if ':' in display_hostname: display_hostname = '[%s]' % display_hostname quit_msg = '(Press CTRL+C to quit)' port = sock.getsockname()[1] _log('info', ' * Running on %s://%s:%d/ %s', ssl_context is None and 'http' or 'https', display_hostname, port, quit_msg) def inner(): try: fd = int(os.environ['WERKZEUG_SERVER_FD']) except (LookupError, ValueError): fd = None srv = make_server(hostname, port, application, threaded, processes, request_handler, passthrough_errors, ssl_context, fd=fd) if fd is None: log_startup(srv.socket) srv.serve_forever() if use_reloader: # If we're not running already in the subprocess that is the # reloader we want to open up a socket early to make sure the # port is actually available. if os.environ.get('WERKZEUG_RUN_MAIN') != 'true': if port == 0 and not can_open_by_fd: raise ValueError('Cannot bind to a random port with enabled ' 'reloader if the Python interpreter does ' 'not support socket opening by fd.') # Create and destroy a socket so that any exceptions are # raised before we spawn a separate Python interpreter and # lose this ability. address_family = select_ip_version(hostname, port) s = socket.socket(address_family, socket.SOCK_STREAM) s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) s.bind((hostname, port)) if hasattr(s, 'set_inheritable'): s.set_inheritable(True) # If we can open the socket by file descriptor, then we can just # reuse this one and our socket will survive the restarts. if can_open_by_fd: os.environ['WERKZEUG_SERVER_FD'] = str(s.fileno()) s.listen(LISTEN_QUEUE) log_startup(s) else: s.close() # Do not use relative imports, otherwise "python -m werkzeug.serving" # breaks. from werkzeug._reloader import run_with_reloader run_with_reloader(inner, extra_files, reloader_interval, reloader_type) else: inner()
def wsgi(ctx, port, timeout, cdn, proxy_mode, admin_password, db_filter, ws, cron, cron_interval, server_wide_modules, dev): debug, config, params, logger = ( ctx.obj['debug'], ctx.obj['config'], ctx.obj['params'], ctx.obj['logger'] ) # Patch odoo config, since we run with gevent # we do not need multiple workers, but Odoo needs # to be fooled. config['workers'] = 2 config['dev_mode'] = ['all'] config['admin_passwd'] = admin_password config['dbfilter'] = db_filter config['server_wide_modules'] = ','.join(server_wide_modules) # Odoo still uses a deprecated conf module for server_wide_modules import odoo.conf odoo.conf.server_wide_modules = server_wide_modules if ws: from odooku.services.websocket import WebSocketServer as Server else: from odooku.services.wsgi import WSGIServer as Server from odooku.services.wsgi import WSGIApplicationRulesWrapper from odooku.services.cron import CronRunner # Initialize newrelic_agent global newrelic_agent if newrelic_agent and any(key in os.environ for key in [ 'NEW_RELIC_LICENSE_KEY', 'NEW_RELIC_CONFIG_FILE' ]): newrelic_agent.initialize() else: newrelic_agent = None # Keep track of custom config params params.TIMEOUT = timeout params.CDN_ENABLED = cdn params.WS_ENABLED = ws # Load wsgi rules rules = WSGIApplicationRulesWrapper.load() def serve(): max_accept = config['db_maxconn'] if cron: cron_runner = CronRunner() max_accept -= 1 gevent.spawn(cron_runner.run_forever, interval=cron_interval) server = Server( port, max_accept=max_accept, proxy_mode=proxy_mode, rules=rules, newrelic_agent=newrelic_agent, timeout=timeout ) server.serve_forever() if dev: logger.warning("Running in development mode") run_with_reloader(serve) else: serve()
def run_with_reloader(*args, **kwargs): # People keep using undocumented APIs. Do not use this function # please, we do not guarantee that it continues working. from werkzeug._reloader import run_with_reloader return run_with_reloader(*args, **kwargs)
def run(self, app, host=None, port=None, **kwargs): # pragma: no cover """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 reloader_options: A dictionary with options that are passed to the Flask reloader, such as ``extra_files``, ``reloader_type``, etc. :param extra_files: A list of additional files that the Flask reloader should watch. Defaults to ``None``. Deprecated, use ``reloader_options`` instead. :param log_output: If ``True``, the server logs all incoming 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) reloader_options = kwargs.pop('reloader_options', {}) if extra_files: reloader_options['extra_files'] = extra_files 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': try: import simple_websocket # noqa: F401 except ImportError: from werkzeug._internal import _log _log( 'warning', 'WebSocket transport not available. Install ' 'simple-websocket for improved performance.') app.run(host=host, port=port, threaded=True, use_reloader=use_reloader, **reloader_options, **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, **reloader_options) else: run_server() elif self.server.eio.async_mode == 'gevent': from gevent import pywsgi try: from geventwebsocket.handler import WebSocketHandler websocket = True except ImportError: app.logger.warning( 'WebSocket transport not available. Install ' 'gevent-websocket for improved performance.') 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_thread() monkey.patch_time() def run_server(): self.wsgi_server.serve_forever() run_with_reloader(run_server, **reloader_options) else: self.wsgi_server.serve_forever()
def _my_run_simple( hostname, port, application, use_reloader, use_debugger, use_evalex, extra_files, reloader_interval, reloader_type, threaded, processes, request_handler, static_files, passthrough_errors, ssl_context, ): """copy-paste-modify of werkzeug with a wishlist feature hack-added mainly this exists because the whole http server stack (an inheritance hierarchy four classes deep!) does not have a listener/hook interface. so the only thing this function accomplishes is to copy-paste what we need from `werkzeug.serving.run_simple()` *plus* we hold on to the server so we can hack it #here4. details: - this is a refactoring of `werkzeug.serving.run_simple` - if you want to see what the server would be like without this mostly redundant hackery, comment-in #here3 (NOTE you will be WITHOUT jobser). - we follow the structure there as much as is practical to do (while pruning some unnecesary stuff out - spiked at #history-A.1 (the first one, oops) """ if use_debugger: from werkzeug.debug import DebuggedApplication application = DebuggedApplication(application, use_evalex) if static_files: from werkzeug.wsgi import SharedDataMiddleware application = SharedDataMiddleware(application, static_files) def _log_startup(sock): _ssl = (lambda: ssl_context is None and 'http' or 'https')() _hn = hostname _prt = sock.getsockname()[1] _msg = '(Press CTRL+C to quit)' _ws_log('info', ' * Running on %s://%s:%d/ %s', _ssl, _hn, _prt, _msg) def _inner(): fd = None s = os.environ.get('WERKZEUG_SERVER_FD') if s is not None: fd = int(s) srv = ws.make_server(hostname, port, application, threaded, processes, request_handler, passthrough_errors, ssl_context, fd) # :#here4: if use_reloader: _ = ' * WARNING: reloader is on so jobser will not be used!' _ws_log('warn', _) else: # _try_to_capture_that_lyfe(srv) # doesn't add much _hackishly_start_jobser_at_server_start(srv) _hackishly_stop_jobser_at_server_stop(srv) if fd is None: _log_startup(srv.socket) srv.serve_forever() import os if use_reloader: if os.environ.get('WERKZEUG_RUN_MAIN') != 'true': import socket addr_fam = socket.AF_INET s = socket.socket(addr_fam, socket.SOCK_STREAM) s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) _ai = socket.getaddrinfo(hostname, port, addr_fam, socket.SOCK_STREAM, socket.SOL_TCP) _sock_addr = _ai[0][4] # all this is is (host, port) s.bind(_sock_addr) s.set_inheritable(True) os.environ['WERKZEUG_SERVER_FD'] = str(s.fileno()) s.listen(ws.LISTEN_QUEUE) _log_startup(s) from werkzeug._reloader import run_with_reloader run_with_reloader(_inner, extra_files, reloader_interval, reloader_type) else: _inner()
template_type = body.get('type') result = None if template_type == 'mustache': with cd(project_path): renderer = Renderer() result = renderer.render_path(entry, data) elif template_type == 'jinja': env = Environment(loader=FileSystemLoader(project_path)) template = env.get_template(entry) result = template.render(**data) else: return Response(status=400) return Response( content=bytes(result, 'utf-8'), headers={ 'Content-Type': 'text/plain' } ) if __name__ == '__main__': def run(): app.run(debug=Config.DEBUG, host='0.0.0.0', port=Config.PORT) run_with_reloader(run)
def run_with_reloader(*args, **kwargs): # People keep using undocumented APIs. Do not use this function # please, we do not guarantee that it continues working. from werkzeug._reloader import run_with_reloader return run_with_reloader(*args, **kwargs)
from scheduler.scheduler_listener import listener def scheduler_instant(): """调度实例""" scheduler.init_app(app) # 添加全局监听器 scheduler.add_listener(listener, EVENT_JOB_EXECUTED | EVENT_JOB_ERROR) scheduler.start() def rpc_instant(): """rpc服务端""" t3 = ThreadedServer(RPCServer, port=config.exec.port, protocol_config=rpyc.core.protocol.DEFAULT_CONFIG) t3.start() def inner(): """启动服务""" # 调度对象 t1 = threading.Thread(target=scheduler_instant) t1.start() # rpc服务端 rpc_instant() if __name__ == '__main__': run_with_reloader(inner)