本文整理汇总了Python中werkzeug.serving.run_with_reloader函数的典型用法代码示例。如果您正苦于以下问题:Python run_with_reloader函数的具体用法?Python run_with_reloader怎么用?Python run_with_reloader使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了run_with_reloader函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: runserver
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)
示例2: run
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
示例3: serve
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)
示例4: run
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()
示例5: __call__
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()
示例6: 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()
示例7: runServer
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
示例8: main
def main():
p = parser()
args = p.parse_args()
def helper():
run_args(args)
if args.reload:
run_with_reloader(helper)
else:
helper()
示例9: callback
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)
示例10: start
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)
示例11: run_wsgi_app_with_cherrypy
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()
示例12: run
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()
示例13: run
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...'
示例14: run
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()
示例15: runServer
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