def __init__(self, volume_manager, context):
"""
Args:
volume_manager (VolumeManager): The repository object to work with the volumes
context (dict): A dict containing `host` and `port`
"""
self._api_loop = None
self._api_server = None
self._started = False
self._connection = ('', 5000)
try:
self._connection = (context['host'], int(context['port']))
except (KeyError, ValueError) as error:
print('Context provided to api erroneous: {}, defaulting: {}\n{}'.format(context, self._connection, error))
self.flask_app = Api._create_app(volume_manager)
self._api_server = WSGIServer(self._connection, self.flask_app)
python类WSGIServer()的实例源码
def run(options):
import gluon.main
if options.password != '<recycle>':
gluon.main.save_password(options.password, int(options.port))
if options.logging:
application = gluon.main.appfactory(wsgiapp=gluon.main.wsgibase,
logfilename='httpserver.log',
profiler_dir=profiler)
else:
application = gluon.main.wsgibase
address = (options.ip, int(options.port))
workers = options.workers
spawn = workers and Pool(int(options.workers)) or 'default'
ssl_args = dict()
if options.ssl_private_key:
ssl_args['keyfile'] = options.ssl_private_key
if options.ssl_certificate:
ssl_args['certfile'] = options.ssl_certificate
server = pywsgi.WSGIServer(
address, application,
spawn=spawn, log=None,
**ssl_args
)
server.serve_forever()
def run(options):
import gluon.main
if options.password != '<recycle>':
gluon.main.save_password(options.password, int(options.port))
if options.logging:
application = gluon.main.appfactory(wsgiapp=gluon.main.wsgibase,
logfilename='httpserver.log',
profiler_dir=profiler)
else:
application = gluon.main.wsgibase
address = (options.ip, int(options.port))
workers = options.workers
spawn = workers and Pool(int(options.workers)) or 'default'
ssl_args = dict()
if options.ssl_private_key:
ssl_args['keyfile'] = options.ssl_private_key
if options.ssl_certificate:
ssl_args['certfile'] = options.ssl_certificate
server = pywsgi.WSGIServer(
address, application,
spawn=spawn, log=None,
**ssl_args
)
server.serve_forever()
def run(options):
import gluon.main
if options.password != '<recycle>':
gluon.main.save_password(options.password, int(options.port))
if options.logging:
application = gluon.main.appfactory(wsgiapp=gluon.main.wsgibase,
logfilename='httpserver.log',
profiler_dir=profiler)
else:
application = gluon.main.wsgibase
address = (options.ip, int(options.port))
workers = options.workers
spawn = workers and Pool(int(options.workers)) or 'default'
ssl_args = dict()
if options.ssl_private_key:
ssl_args['keyfile'] = options.ssl_private_key
if options.ssl_certificate:
ssl_args['certfile'] = options.ssl_certificate
server = pywsgi.WSGIServer(
address, application,
spawn=spawn, log=None,
**ssl_args
)
server.serve_forever()
web2py_on_gevent.py 文件源码
项目:rekall-agent-server
作者: rekall-innovations
项目源码
文件源码
阅读 21
收藏 0
点赞 0
评论 0
def run(options):
import gluon.main
if options.password != '<recycle>':
gluon.main.save_password(options.password, int(options.port))
if options.logging:
application = gluon.main.appfactory(wsgiapp=gluon.main.wsgibase,
logfilename='httpserver.log',
profiler_dir=profiler)
else:
application = gluon.main.wsgibase
address = (options.ip, int(options.port))
workers = options.workers
spawn = workers and Pool(int(options.workers)) or 'default'
ssl_args = dict()
if options.ssl_private_key:
ssl_args['keyfile'] = options.ssl_private_key
if options.ssl_certificate:
ssl_args['certfile'] = options.ssl_certificate
server = pywsgi.WSGIServer(
address, application,
spawn=spawn, log=None,
**ssl_args
)
server.serve_forever()
def run(self, handler):
context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)
context.load_cert_chain(handler.certificate_file, handler.private_key_file)
context.load_verify_locations(cafile=handler.certificate_file)
context.load_verify_locations(cafile=handler.crl_file)
context.options &= ssl.OP_NO_SSLv3
context.options &= ssl.OP_NO_SSLv2
context.verify_flags |= ssl.VERIFY_CRL_CHECK_LEAF
context.verify_mode = ssl.CERT_OPTIONAL
self.options['ssl_context'] = context
logger.info('Starting server on host %s port %d.', self.host, self.port)
server = pywsgi.WSGIServer(
(self.host, self.port),
handler,
ssl_context=context,
handler_class=RequestHandler,
log=logger,
error_log=logger,
)
server.serve_forever()
def run(options):
import gluon.main
if options.password != '<recycle>':
gluon.main.save_password(options.password, int(options.port))
if options.logging:
application = gluon.main.appfactory(wsgiapp=gluon.main.wsgibase,
logfilename='httpserver.log',
profiler_dir=profiler)
else:
application = gluon.main.wsgibase
address = (options.ip, int(options.port))
workers = options.workers
spawn = workers and Pool(int(options.workers)) or 'default'
ssl_args = dict()
if options.ssl_private_key:
ssl_args['keyfile'] = options.ssl_private_key
if options.ssl_certificate:
ssl_args['certfile'] = options.ssl_certificate
server = pywsgi.WSGIServer(
address, application,
spawn=spawn, log=None,
**ssl_args
)
server.serve_forever()
def inner_run(self, *args, **options):
# Check if we are using the correct database engine configuration.
if db.connection.settings_dict['ENGINE'] != 'django_db_geventpool.backends.postgresql_psycopg2':
raise exceptions.ImproperlyConfigured("Django REST Framework Reactive requires the geventpool database engine.")
# Make the pool gevent-ready.
pool.set_backend(GeventBackend())
# Register the event handler for receiving model updates from the Django ORM.
event_handler = rpc.RedisObserverEventHandler()
gevent.spawn(event_handler)
# Prepare the RPC server.
info = connection.get_queryobserver_settings()
rpc_server = pywsgi.WSGIServer((info['host'], info['port']), application=rpc.WSGIObserverCommandHandler())
rpc_server.serve_forever()
def run(options):
import gluon.main
if options.password != '<recycle>':
gluon.main.save_password(options.password, int(options.port))
if options.logging:
application = gluon.main.appfactory(wsgiapp=gluon.main.wsgibase,
logfilename='httpserver.log',
profiler_dir=profiler)
else:
application = gluon.main.wsgibase
address = (options.ip, int(options.port))
workers = options.workers
spawn = workers and Pool(int(options.workers)) or 'default'
ssl_args = dict()
if options.ssl_private_key:
ssl_args['keyfile'] = options.ssl_private_key
if options.ssl_certificate:
ssl_args['certfile'] = options.ssl_certificate
server = pywsgi.WSGIServer(
address, application,
spawn=spawn, log=None,
**ssl_args
)
server.serve_forever()
def run(self, handler): # pragma: no cover
import flup.server.fcgi
self.options.setdefault('bindAddress', (self.host, self.port))
flup.server.fcgi.WSGIServer(handler, **self.options).run()
def run(self, app): # pragma: no cover
from wsgiref.simple_server import make_server
from wsgiref.simple_server import WSGIRequestHandler, WSGIServer
import socket
class FixedHandler(WSGIRequestHandler):
def address_string(self): # Prevent reverse DNS lookups please.
return self.client_address[0]
def log_request(*args, **kw):
if not self.quiet:
return WSGIRequestHandler.log_request(*args, **kw)
handler_cls = self.options.get('handler_class', FixedHandler)
server_cls = self.options.get('server_class', WSGIServer)
if ':' in self.host: # Fix wsgiref for IPv6 addresses.
if getattr(server_cls, 'address_family') == socket.AF_INET:
class server_cls(server_cls):
address_family = socket.AF_INET6
self.srv = make_server(self.host, self.port, app, server_cls,
handler_cls)
self.port = self.srv.server_port # update port actual port (0 means random)
try:
self.srv.serve_forever()
except KeyboardInterrupt:
self.srv.server_close() # Prevent ResourceWarning: unclosed socket
raise
def run(self, handler):
from gevent import pywsgi, local
if not isinstance(threading.local(), local.local):
msg = "Bottle requires gevent.monkey.patch_all() (before import)"
raise RuntimeError(msg)
if self.quiet:
self.options['log'] = None
address = (self.host, self.port)
server = pywsgi.WSGIServer(address, handler, **self.options)
if 'BOTTLE_CHILD' in os.environ:
import signal
signal.signal(signal.SIGINT, lambda s, f: server.stop())
server.serve_forever()
def main():
# socketio.run(app)
from gevent import pywsgi
from geventwebsocket.handler import WebSocketHandler
server = pywsgi.WSGIServer(('', 5050), app, handler_class=WebSocketHandler)
server.serve_forever()
def start_server():
from gevent import pywsgi
from geventwebsocket.handler import WebSocketHandler
server = pywsgi.WSGIServer(('', 5000), app, handler_class=WebSocketHandler)
server.serve_forever()
def _run_app(self, crt_path=None, key_path=None):
Logger.info('AppController: _run_app:')
try:
gevent_kwargs = {
'log': AppController.GeventLoggerInfo,
'error_log': AppController.GeventLoggerError}
if crt_path and key_path:
found_ssl = True
for x in (crt_path, key_path):
if not os.path.exists(x):
found_ssl = False
if found_ssl:
gevent_kwargs['certfile'] = crt_path
gevent_kwargs['keyfile'] = key_path
else:
Logger.warning('AppController: _run_app: cert and key '
'were not found, starting without')
self.ip = '0.0.0.0'
self.port = 5000
self.using_ssl = found_ssl
self.server = pywsgi.WSGIServer(
(self.ip, self.port), app, **gevent_kwargs)
self._set_started_true()
self.server.serve_forever()
except:
Logger.error('AppController: %s' % traceback.format_exc())
def run_gevent_server(app, port):
from gevent.pywsgi import WSGIServer
import gevent.monkey
gevent.monkey.patch_all()
log.info("Activating gevent server on port %s", port)
http_server = WSGIServer(('', port), app)
http_server.serve_forever()
def start(self):
handler = self.handleRequest
if config.debug:
# Auto reload UiRequest on change
from Debug import DebugReloader
DebugReloader(self.reload)
# Werkzeug Debugger
try:
from werkzeug.debug import DebuggedApplication
handler = DebuggedApplication(self.handleRequest, evalex=True)
except Exception, err:
self.log.info("%s: For debugging please download Werkzeug (http://werkzeug.pocoo.org/)" % err)
from Debug import DebugReloader
self.log.write = lambda msg: self.log.debug(msg.strip()) # For Wsgi access.log
self.log.info("--------------------------------------")
self.log.info("Web interface: http://%s:%s/" % (config.ui_ip, config.ui_port))
self.log.info("--------------------------------------")
if config.open_browser:
logging.info("Opening browser: %s...", config.open_browser)
import webbrowser
if config.open_browser == "default_browser":
browser = webbrowser.get()
else:
browser = webbrowser.get(config.open_browser)
browser.open("http://%s:%s" % (config.ui_ip if config.ui_ip != "*" else "127.0.0.1", config.ui_port), new=2)
self.server = WSGIServer((self.ip.replace("*", ""), self.port), handler, handler_class=UiWSGIHandler, log=self.log)
self.server.sockets = {}
try:
self.server.serve_forever()
except Exception, err:
self.log.error("Web interface bind error, must be running already, exiting.... %s" % err)
sys.modules["main"].file_server.stop()
self.log.debug("Stopped.")
def run(self, handler): # pragma: no cover
import flup.server.fcgi
self.options.setdefault('bindAddress', (self.host, self.port))
flup.server.fcgi.WSGIServer(handler, **self.options).run()
def run(self, app): # pragma: no cover
from wsgiref.simple_server import make_server
from wsgiref.simple_server import WSGIRequestHandler, WSGIServer
import socket
class FixedHandler(WSGIRequestHandler):
def address_string(self): # Prevent reverse DNS lookups please.
return self.client_address[0]
def log_request(*args, **kw):
if not self.quiet:
return WSGIRequestHandler.log_request(*args, **kw)
handler_cls = self.options.get('handler_class', FixedHandler)
server_cls = self.options.get('server_class', WSGIServer)
if ':' in self.host: # Fix wsgiref for IPv6 addresses.
if getattr(server_cls, 'address_family') == socket.AF_INET:
class server_cls(server_cls):
address_family = socket.AF_INET6
self.srv = make_server(self.host, self.port, app, server_cls,
handler_cls)
self.port = self.srv.server_port # update port actual port (0 means random)
try:
self.srv.serve_forever()
except KeyboardInterrupt:
self.srv.server_close() # Prevent ResourceWarning: unclosed socket
raise
def run(self, handler):
from gevent import pywsgi, local
if not isinstance(threading.local(), local.local):
msg = "Bottle requires gevent.monkey.patch_all() (before import)"
raise RuntimeError(msg)
if self.quiet:
self.options['log'] = None
address = (self.host, self.port)
server = pywsgi.WSGIServer(address, handler, **self.options)
if 'BOTTLE_CHILD' in os.environ:
import signal
signal.signal(signal.SIGINT, lambda s, f: server.stop())
server.serve_forever()
def flup(app, address, **options):
import flup.server.fcgi
flup.server.fcgi.WSGIServer(app, bindAddress=address).run()
def gevent(app, address, **options):
options = options['options']
workers = options.workers
from gevent import pywsgi
from gevent.pool import Pool
pywsgi.WSGIServer(address, app, spawn=workers and Pool(
int(options.workers)) or 'default', log=None).serve_forever()
def pulsar(app, address, **options):
from pulsar.apps import wsgi
sys.argv = ['anyserver.py']
s = wsgi.WSGIServer(callable=app, bind="%s:%d" % address)
s.start()
def run(self, handler): # pragma: no cover
import flup.server.fcgi
self.options.setdefault('bindAddress', (self.host, self.port))
flup.server.fcgi.WSGIServer(handler, **self.options).run()
def run(self, app): # pragma: no cover
from wsgiref.simple_server import make_server
from wsgiref.simple_server import WSGIRequestHandler, WSGIServer
import socket
class FixedHandler(WSGIRequestHandler):
def address_string(self): # Prevent reverse DNS lookups please.
return self.client_address[0]
def log_request(*args, **kw):
if not self.quiet:
return WSGIRequestHandler.log_request(*args, **kw)
handler_cls = self.options.get('handler_class', FixedHandler)
server_cls = self.options.get('server_class', WSGIServer)
if ':' in self.host: # Fix wsgiref for IPv6 addresses.
if getattr(server_cls, 'address_family') == socket.AF_INET:
class server_cls(server_cls):
address_family = socket.AF_INET6
self.srv = make_server(self.host, self.port, app, server_cls,
handler_cls)
self.port = self.srv.server_port # update port actual port (0 means random)
try:
self.srv.serve_forever()
except KeyboardInterrupt:
self.srv.server_close() # Prevent ResourceWarning: unclosed socket
raise
def run(self, handler):
from gevent import pywsgi, local
if not isinstance(threading.local(), local.local):
msg = "Bottle requires gevent.monkey.patch_all() (before import)"
raise RuntimeError(msg)
if self.quiet:
self.options['log'] = None
address = (self.host, self.port)
server = pywsgi.WSGIServer(address, handler, **self.options)
if 'BOTTLE_CHILD' in os.environ:
import signal
signal.signal(signal.SIGINT, lambda s, f: server.stop())
server.serve_forever()
def run(self, handler): # pragma: no cover
import flup.server.fcgi
self.options.setdefault('bindAddress', (self.host, self.port))
flup.server.fcgi.WSGIServer(handler, **self.options).run()
def run(self, app): # pragma: no cover
from wsgiref.simple_server import make_server
from wsgiref.simple_server import WSGIRequestHandler, WSGIServer
import socket
class FixedHandler(WSGIRequestHandler):
def address_string(self): # Prevent reverse DNS lookups please.
return self.client_address[0]
def log_request(*args, **kw):
if not self.quiet:
return WSGIRequestHandler.log_request(*args, **kw)
handler_cls = self.options.get('handler_class', FixedHandler)
server_cls = self.options.get('server_class', WSGIServer)
if ':' in self.host: # Fix wsgiref for IPv6 addresses.
if getattr(server_cls, 'address_family') == socket.AF_INET:
class server_cls(server_cls):
address_family = socket.AF_INET6
self.srv = make_server(self.host, self.port, app, server_cls,
handler_cls)
self.port = self.srv.server_port # update port actual port (0 means random)
try:
self.srv.serve_forever()
except KeyboardInterrupt:
self.srv.server_close() # Prevent ResourceWarning: unclosed socket
raise
def run(self, handler):
from gevent import pywsgi, local
if not isinstance(threading.local(), local.local):
msg = "Bottle requires gevent.monkey.patch_all() (before import)"
raise RuntimeError(msg)
if self.quiet:
self.options['log'] = None
address = (self.host, self.port)
server = pywsgi.WSGIServer(address, handler, **self.options)
if 'BOTTLE_CHILD' in os.environ:
import signal
signal.signal(signal.SIGINT, lambda s, f: server.stop())
server.serve_forever()
def flup(app, address, **options):
import flup.server.fcgi
flup.server.fcgi.WSGIServer(app, bindAddress=address).run()