def main(argv):
global delay_time, delay_type
try:
opts, args = getopt.getopt(argv, "d:t:")
except getopt.GetoptError:
print 'Error'
sys.exit(2)
for opt, arg in opts:
if opt == '-d':
delay_type = arg
elif opt == '-t':
delay_time = arg
delay_time = int(delay_time)
if (delay_type):
if (delay_type != 'constant') and (delay_type != 'random'):
print "Only constant and random are supported"
sys.exit(1)
eventlet.monkey_patch()
app = _make_app()
port = 443
wsgi.server(
eventlet.wrap_ssl(eventlet.listen(('', port)),
certfile=path + '/server.cert',
keyfile=path + '/server.key',
server_side=False), app)
def run_server(conf, logger, sock, global_conf=None):
# Ensure TZ environment variable exists to avoid stat('/etc/localtime') on
# some platforms. This locks in reported times to the timezone in which
# the server first starts running in locations that periodically change
# timezones.
os.environ["TZ"] = time.strftime("%z", time.gmtime())
wsgi.HttpProtocol.default_request_version = "HTTP/1.0"
# Turn off logging requests by the underlying WSGI software.
wsgi.HttpProtocol.log_request = lambda *a: None
# Redirect logging other messages by the underlying WSGI software.
wsgi.HttpProtocol.log_message = lambda s, f, *a: logger.error("ERROR WSGI: " + f % a)
wsgi.WRITE_TIMEOUT = int(conf.get("client_timeout") or 60)
eventlet.hubs.use_hub(get_hub())
eventlet.patcher.monkey_patch(all=False, socket=True)
eventlet_debug = config_true_value(conf.get("eventlet_debug", "no"))
eventlet.debug.hub_exceptions(eventlet_debug)
# utils.LogAdapter stashes name in server; fallback on unadapted loggers
if not global_conf:
if hasattr(logger, "server"):
log_name = logger.server
else:
log_name = logger.name
global_conf = {"log_name": log_name}
app = loadapp(conf["__file__"], global_conf=global_conf)
max_clients = int(conf.get("max_clients", "1024"))
pool = RestrictedGreenPool(size=max_clients)
try:
wsgi.server(sock, app, NullLogger(), custom_pool=pool)
except socket.error as err:
if err[0] != errno.EINVAL:
raise
pool.waitall()
def main():
"""Run the server."""
global OPTIONS # pylint: disable=W0603
parser = OptionParser()
parser.add_option("-d", "--checkdir", dest="checkdir", metavar="DIR",
default="/usr/lib/nagios/plugins", help="directory with check scripts")
parser.add_option("-l", "--log-level", dest="loglevel", metavar="LEVEL",
help="logging level", default='info')
parser.add_option("-g", "--graphite", dest="graphite", metavar="GRAPHITE_HOST",
help="graphite host, specify as host:post", default='')
parser.add_option("-p", "--port", dest="port", metavar="PORT",
help="port to listen on", default=8111, type="int")
OPTIONS = parser.parse_args()[0]
levelName = {'debug': logging.DEBUG, 'info': logging.INFO, 'warn': logging.WARN, 'error': logging.ERROR}
logging.basicConfig(level=levelName.get(OPTIONS.loglevel.lower(), logging.WARN))
if OPTIONS.graphite:
from greplin.scales import util
host, port = OPTIONS.graphite.split(':')
global GRAPHITE # pylint: disable=W0603
GRAPHITE = util.GraphiteReporter(host, int(port))
GRAPHITE.start()
wsgi.server(eventlet.listen(('', int(OPTIONS.port))), APP)
def run_server(conf, logger, sock):
wsgi.HttpProtocol.default_request_version = "HTTP/1.0"
# Turn off logging requests by the underlying WSGI software.
wsgi.HttpProtocol.log_request = lambda *a: None
# Redirect logging other messages by the underlying WSGI software.
wsgi.HttpProtocol.log_message = \
lambda s, f, *a: logger.error('ERROR WSGI: ' + f % a)
wsgi.WRITE_TIMEOUT = int(conf.get('client_timeout') or 60)
eventlet.hubs.use_hub(get_hub())
eventlet.patcher.monkey_patch(all=False, socket=True)
eventlet_debug = config_true_value(conf.get('eventlet_debug', 'no'))
eventlet.debug.hub_exceptions(eventlet_debug)
# utils.LogAdapter stashes name in server; fallback on unadapted loggers
if hasattr(logger, 'server'):
log_name = logger.server
else:
log_name = logger.name
app = loadapp(conf['__file__'], global_conf={'log_name': log_name})
max_clients = int(conf.get('max_clients', '1024'))
pool = RestrictedGreenPool(size=max_clients)
try:
wsgi.server(sock, app, NullLogger(), custom_pool=pool)
except socket.error, err:
if err[0] != errno.EINVAL:
raise
def _single_run(self, application, sock):
"""Start a WSGI server in a new green thread."""
LOG.info("Starting single process server")
eventlet_wsgi.server(sock, application,
custom_pool=self.pool,
log=WSGILog(LOG),
debug=False)
def start(self):
"""Run the blocking eventlet WSGI server.
:returns: None
"""
wsgi.server(self._socket, self.app)
def main():
"""Run the server."""
global OPTIONS # pylint: disable=W0603
parser = OptionParser()
parser.add_option("-d", "--checkdir", dest="checkdir", metavar="DIR",
default="/usr/lib/nagios/plugins", help="directory with check scripts")
parser.add_option("-l", "--log-level", dest="loglevel", metavar="LEVEL",
help="logging level", default='info')
parser.add_option("-g", "--graphite", dest="graphite", metavar="GRAPHITE_HOST",
help="graphite host, specify as host:post", default='')
parser.add_option("-p", "--port", dest="port", metavar="PORT",
help="port to listen on", default=8111, type="int")
OPTIONS = parser.parse_args()[0]
levelName = {'debug': logging.DEBUG, 'info': logging.INFO, 'warn': logging.WARN, 'error': logging.ERROR}
logging.basicConfig(level=levelName.get(OPTIONS.loglevel.lower(), logging.WARN))
if OPTIONS.graphite:
from greplin.scales import util
host, port = OPTIONS.graphite.split(':')
global GRAPHITE # pylint: disable=W0603
GRAPHITE = util.GraphiteReporter(host, int(port))
GRAPHITE.start()
wsgi.server(eventlet.listen(('', int(OPTIONS.port))), APP)
def _run_server():
host = cfg.CONF.auth.host
port = cfg.CONF.auth.port
use_ssl = cfg.CONF.auth.use_ssl
cert_file_path = os.path.realpath(cfg.CONF.auth.cert)
key_file_path = os.path.realpath(cfg.CONF.auth.key)
if use_ssl and not os.path.isfile(cert_file_path):
raise ValueError('Certificate file "%s" doesn\'t exist' % (cert_file_path))
if use_ssl and not os.path.isfile(key_file_path):
raise ValueError('Private key file "%s" doesn\'t exist' % (key_file_path))
socket = eventlet.listen((host, port))
if use_ssl:
socket = eventlet.wrap_ssl(socket,
certfile=cert_file_path,
keyfile=key_file_path,
server_side=True)
LOG.info('ST2 Auth API running in "%s" auth mode', cfg.CONF.auth.mode)
LOG.info('(PID=%s) ST2 Auth API is serving on %s://%s:%s.', os.getpid(),
'https' if use_ssl else 'http', host, port)
wsgi.server(socket, app.setup_app())
return 0
def start(self, start_listeners=True):
self.log('Server', 'info', 'starting server')
for name in self.config.components:
self.components[name] = self.config.components.import_(name)(self,
name)
self._greenlet = eventlet.spawn(self._process)
if start_listeners and 'backdoor_port' in self.config.server:
# enable backdoor console
bdport = self.config.getint(('server', 'backdoor_port'))
self.log('Server', 'info', 'enabling backdoor on port %s'
% bdport)
eventlet.spawn(backdoor.backdoor_server,
eventlet.listen(('127.0.0.1', bdport)),
locals={'server': self,
'debug': debug,
'exit': safe_exit(),
'quit': safe_exit(),
'stats': lambda: pprint.pprint(self.stats()),
})
app = create_application(self)
dirs = self.config.server.get('static_directories', None)
if dirs is not None:
app = StaticFileServer(dirs.split(','), app, self)
self.wsgiapp = app
if start_listeners:
numsimulreq = self.config.get(('http', 'max_simultaneous_reqs'))
host = self.config.http.address
port = self.config.http.getint('port')
sock = eventlet.listen((host, port))
pool = self.server_pool = eventlet.GreenPool(10000)
log = (self.options.nohttp or self.options.statdump) and \
dummylog() or None
wsgi.server(sock, app, custom_pool=pool, log=log)
def main():
parser = argparse.ArgumentParser(description='HTTP/2 ServerSentEvents server')
parser.add_argument('-p', dest='port', default=5000, type=int, help='Port')
args = parser.parse_args()
listener = eventlet.listen(('0.0.0.0', args.port))
wsgi.server(listener, app)
def _run_server():
host = cfg.CONF.auth.host
port = cfg.CONF.auth.port
use_ssl = cfg.CONF.auth.use_ssl
cert_file_path = os.path.realpath(cfg.CONF.auth.cert)
key_file_path = os.path.realpath(cfg.CONF.auth.key)
if use_ssl and not os.path.isfile(cert_file_path):
raise ValueError('Certificate file "%s" doesn\'t exist' %
(cert_file_path))
if use_ssl and not os.path.isfile(key_file_path):
raise ValueError('Private key file "%s" doesn\'t exist' %
(key_file_path))
socket = eventlet.listen((host, port))
if use_ssl:
socket = eventlet.wrap_ssl(socket,
certfile=cert_file_path,
keyfile=key_file_path,
server_side=True)
LOG.info('ST2 Auth API running in "%s" auth mode', cfg.CONF.auth.mode)
LOG.info('(PID=%s) ST2 Auth API is serving on %s://%s:%s.', os.getpid(),
'https' if use_ssl else 'http', host, port)
wsgi.server(socket, app.setup_app())
return 0
def start_event_loop(self):
def on_request(env, start_response):
if env['PATH_INFO'] != self.report_path:
start_response('404 Not Found', [('Content-Type', 'text/plain')])
return ['Not Found\r\n']
response_data = 'OK\r\n'
start_response('200 OK', [('Content-Type', 'text/plain'),
('Content-Length', len(response_data)),])
try:
content_length = int(env.get('CONTENT_LENGTH', 0))
except (ValueError):
content_length = 0
wsgi_input = env['wsgi.input']
body = wsgi_input.read(content_length)
LOG.debug("Receive data : %s Length : %d" % (body, content_length))
self.handle_receive_data(body)
return [response_data]
#Do not log wsgi info
try:
log_dev = file('/dev/zero', 'w')
except:
log_dev = None
wsgi.server(self.listener, on_request, log_dev, debug=False)
def main():
"""Entry point to start API wsgi server."""
api.register_all()
app = VersionSelectorApplication()
wsgi.server(eventlet.listen((CONF.host, CONF.port), backlog=500), app)
def start_server(mapper, addr, pid_file=None, daemon=False, server=None):
# Start on daemon mode
if daemon:
_daemon()
# load application and get host and PORT
app = load_router(mapper)
# write PID into the lock file.
if pid_file:
pid_file = os.path.abspath(os.path.expanduser(pid_file))
with open(pid_file, 'w') as f:
f.write(str(os.getpid()))
# Start the server.
if server:
server(addr, app)
else:
import eventlet
from eventlet import wsgi
eventlet.patcher.monkey_patch(os=True, select=True, socket=True, thread=True, time=True)
# Create the wsgi application and start the server.
sock = eventlet.listen(addr)
wsgi.server(sock, app)
def start_server(mapper, addr, pid_file=None, daemon=False, server=None):
# Start on daemon mode
if daemon:
_daemon()
# load application and get host and PORT
app = load_router(mapper)
# write PID into the lock file.
if pid_file:
pid_file = os.path.abspath(os.path.expanduser(pid_file))
with open(pid_file, 'w') as f:
f.write(str(os.getpid()))
# Start the server.
if server:
server(addr, app)
else:
import eventlet
from eventlet import wsgi
eventlet.patcher.monkey_patch(os=True,
select=True,
socket=True,
thread=True,
time=True)
# Create the wsgi application and start the server.
sock = eventlet.listen(addr)
wsgi.server(sock, app)
def start_server(app):
sock = eventlet.listen((cfg.CONF.host, cfg.CONF.port), backlog=500)
if sslutils.is_enabled():
LOG.info(_LI("Using HTTPS for port %s"), cfg.CONF.port)
sock = sslutils.wrap(sock)
wsgi.server(sock, app, log=loggers.WritableLogger(LOG), debug=False)
def run(port):
global q
global srv
import gluon.main
from gluon.settings import global_settings
global_settings.web2py_crontype = "soft"
queue_interpreter = Queue.Queue()
thread.start_new_thread(_toggle_command, (queue_interpreter, q))
thread.start_new_thread(_interpreter, (queue_interpreter, q))
app = TraceResponseHeaderMiddleware(gluon.main.wsgibase)
try:
1 / 0
import eventlet
from eventlet import wsgi
WSOUT("Using eventlet")
wsgi.server(eventlet.listen(("", port)), app)
except Exception, e:
# print e
srv = make_server("", port, app, handler_class=RequestHandler)
WSOUT("Using wsgiref")
srv.serve_forever()
def main():
from eventlet import wsgi,wrap_ssl,listen
from ankisyncd.thread import shutdown
config = SafeConfigParser()
config.read("ankisyncd.conf")
ankiserver = SyncApp(config)
host = config.get("sync_app", "host")
port = config.getint("sync_app", "port")
if(config.getboolean("sync_app", "ssl")):
certfile = config.get("sync_app", "certfile")
keyfile = config.get("sync_app", "keyfile")
socket = wrap_ssl( listen((host, port)),
certfile=certfile,
keyfile=keyfile,
server_side=True )
else:
socket = listen((host, port))
try:
wsgi.server(socket, ankiserver)
finally:
shutdown()
def main(*args, **kwargs):
options, args = parser.parse_args(*args, **kwargs)
if not args:
parser.error('missing config file')
elif len(args) > 1:
parser.error('too many arguments')
elif not os.path.isfile(args[0]):
parser.error(args[0] + ' does not exist')
config_file = os.path.abspath(args[0])
debug = options.debug
level = options.verbosity or (logging.DEBUG if debug else logging.WARNING)
logging.basicConfig(level=level)
app.debug = debug
app.config.from_pyfile(config_file)
for conf in REQUIRED_CONFIGS:
if conf not in app.config:
parser.error('missing config: ' + conf)
oauth = app.config['OAUTH']
oauth['request_token_params'] = oauth.get('request_token_params', {})
if options.force_https:
app.wsgi_app = ForcingHTTPSMiddleware(app.wsgi_app)
if options.proxy_fix:
app.wsgi_app = ProxyFix(app.wsgi_app)
app.config['SAVE_DIRECTORY'] = os.path.abspath(
app.config['SAVE_DIRECTORY']
)
server(listen((options.host, options.port)), app)
def run(self):
upgrade()
if self.debug:
app.run(host=self.host, port=self.port, debug=self.debug)
else:
wsgi.server(eventlet.listen((self.host, self.port)), app)
def run_server(conf, logger, sock, global_conf=None):
# Ensure TZ environment variable exists to avoid stat('/etc/localtime') on
# some platforms. This locks in reported times to the timezone in which
# the server first starts running in locations that periodically change
# timezones.
os.environ['TZ'] = time.strftime("%z", time.gmtime())
wsgi.HttpProtocol.default_request_version = "HTTP/1.0"
# Turn off logging requests by the underlying WSGI software.
wsgi.HttpProtocol.log_request = lambda *a: None
# Redirect logging other messages by the underlying WSGI software.
wsgi.HttpProtocol.log_message = \
lambda s, f, *a: logger.error('ERROR WSGI: ' + f % a)
wsgi.WRITE_TIMEOUT = int(conf.get('client_timeout') or 60)
eventlet.hubs.use_hub(get_hub())
eventlet.patcher.monkey_patch(all=False, socket=True)
eventlet_debug = config_true_value(conf.get('eventlet_debug', 'no'))
eventlet.debug.hub_exceptions(eventlet_debug)
# utils.LogAdapter stashes name in server; fallback on unadapted loggers
if not global_conf:
if hasattr(logger, 'server'):
log_name = logger.server
else:
log_name = logger.name
global_conf = {'log_name': log_name}
app = loadapp(conf['__file__'], global_conf=global_conf)
max_clients = int(conf.get('max_clients', '1024'))
pool = RestrictedGreenPool(size=max_clients)
try:
wsgi.server(sock, app, NullLogger(), custom_pool=pool)
except socket.error as err:
if err[0] != errno.EINVAL:
raise
pool.waitall()
def _run(self, application, socket):
"""Start a WSGI server in a new green thread."""
logger = logging.getLogger('eventlet.wsgi')
wsgi.server(socket,
application,
custom_pool=self.pool,
log=WritableLogger(logger))
def run(self):
listener = eventlet.listen(('127.0.0.1', 7000))
wsgi.server(listener,
dispatch,
log_output=False,
environ=self.mainWorker)
def main():
out = Out()
out.init("Kiwi report browser.")
parser = argparse.ArgumentParser(description="Kiwi. Audit source code"
" for security issuses")
parser.add_argument("-p", "--port", type=int,
help=u"指定监听端口，默认为5000")
parser.add_argument("--ip", help=u"指定监听IP")
parser.add_argument("-d", "--report_path", help=u"指定扫描报告目录")
args = parser.parse_args()
port = args.port or 5000
ip = args.ip or '0.0.0.0'
report_path = args.report_path or os.getenv("KIWI_REPORT_PATH")
if not report_path:
out.error(u"未指定报告目录，请使用-d/--report_path参数或者"
u"KIWI_REPORT_PATH环境变量指定报告目录")
exit(1)
application.report_path = os.path.realpath(report_path)
wsgi.server(eventlet.listen((ip, port)), application)
def run(self):
upgrade()
app.wsgi_app = WSGIErrorMiddleware(app.wsgi_app)
if self.debug:
app.run(host=self.host, port=self.port, debug=self.debug)
else:
wsgi.server(eventlet.listen((self.host, self.port)), app)
def _run_server():
host = cfg.CONF.stream.host
port = cfg.CONF.stream.port
LOG.info(
"(PID=%s) ST2 Stream API is serving on http://%s:%s.", os.getpid(), host, port
)
max_pool_size = eventlet.wsgi.DEFAULT_MAX_SIMULTANEOUS_REQUESTS
worker_pool = eventlet.GreenPool(max_pool_size)
sock = eventlet.listen((host, port))
def queue_shutdown(signal_number, stack_frame):
eventlet.spawn_n(
shutdown_server_kill_pending_requests,
sock=sock,
worker_pool=worker_pool,
wait_time=WSGI_SERVER_REQUEST_SHUTDOWN_TIME,
)
# We register a custom SIGINT handler which allows us to kill long running active requests.
# Note: Eventually we will support draining (waiting for short-running requests), but we
# will still want to kill long running stream requests.
register_stream_signal_handlers(handler_func=queue_shutdown)
wsgi.server(sock, app.setup_app(), custom_pool=worker_pool)
return 0
def serve(application, host='127.0.0.1', port=8080):
"""Eventlet-based WSGI-HTTP server.
For a more fully-featured Eventlet-capable interface, see also [Spawning](http://pypi.python.org/pypi/Spawning/).
"""
# Instantiate the server with a bound port and with our application.
server(listen(host, int(port)), application)
def run_wsgi_app(app, port):
"""Run a wsgi compatible app using eventlet"""
print "starting eventlet server on port %i" % port
wsgi.server(
eventlet.listen(('', port)),
app,
max_size=25,
)
def main():
configfile = "server-api.ini"
appname = "rootApp"
wsgi_app = loadapp("config:%s" % os.path.abspath(configfile), appname)
# print CONF.bind_host, CONF.bind_port
wsgi.server(eventlet.listen((CONF.bind_host, CONF.bind_port)), wsgi_app)
def main():
application = app.make_app(sys.argv[1:])
CONF.log_opt_values(LOG, logging.INFO)
try:
wsgi.server(eventlet.listen((CONF.host, CONF.port), backlog=500),
application, log=WritableLogger(LOG))
except KeyboardInterrupt:
pass
def __init__(self, controller, host, port):
self.controller = controller
self.host = host
self.port = port
self.status_waiter = None
self.child_events = {}
socket = eventlet.listen((host, port))
wsgi.server(socket, self.application)
def __init__(self, controller, host, port):
self.controller = controller
self.host = host
self.port = port
self.status_waiter = None
self.child_events = {}
socket = eventlet.listen((host, port))
wsgi.server(socket, self.application)
def _run_server():
host = cfg.CONF.api.host
port = cfg.CONF.api.port
LOG.info('(PID=%s) ST2 API is serving on http://%s:%s.', os.getpid(), host, port)
wsgi.server(eventlet.listen((host, port)), app.setup_app())
return 0
def run_wsgi_app(app, port=8080):
"""Run a wsgi compatible app using eventlet"""
print "starting eventlet server on port %i" % port
wsgi.server(
eventlet.listen(('', port)),
app,
max_size=MAX_GREEN_THREADS,
)
def start_wsgi_server():
"""
Uses WSGI to start a Flask server and listen for requests
"""
paste_file = CONF.paste_ini
wsgi_app = loadapp('config:%s' % paste_file, "main")
listen_port = CONF.listen_port
wsgi.server(eventlet.listen(('', listen_port)), wsgi_app)
def main(): # pragma: no cover
get_env('INFRABOX_DATABASE_HOST')
get_env('INFRABOX_DATABASE_USER')
get_env('INFRABOX_DATABASE_PASSWORD')
get_env('INFRABOX_DATABASE_PORT')
get_env('INFRABOX_DATABASE_DB')
wsgi.server(eventlet.listen(('0.0.0.0', 8080)), app)
def _listen(self):
try:
wsgi.server(eventlet.listen((self.interface, self.port)), self, max_size=self._pool_size)
except Exception, e:
import sys
import traceback
print >>sys.stderr, "*** ERROR", e
traceback.print_tb(sys.exc_info()[2])
def start(self):
explorer_worker_handle = eventlet.spawn(self.explorer.worker)
flask_app = Flask(self.__class__.__name__)
flask_app.debug = True
self.regist_flask_routes(flask_app)
server_sock = eventlet.listen(('localhost', self.listen_port))
wsgi.server(server_sock, flask_app)
raise RuntimeError('should not reach here!')
def run(app, host='', port=8081):
try:
wsgi.server(api.tcp_listener((host, port)), app)
except KeyboardInterrupt:
print '>>> exiting cleanly...'
return 0
finally:
return -1
def main():
try:
import eventlet
from eventlet import wsgi
EVENTS_LOG.info('Using eventlet...')
wsgi.server(eventlet.listen( ('0.0.0.0', int( environ.get( 'PORT', 8000 ) ) ) ), app )
except ImportError:
app.run( host = '0.0.0.0', port = int( environ.get( 'PORT', 8000 ) ), debug = len( argv ) > 1 )
def serve(application, host='127.0.0.1', port=8080): """Eventlet-based WSGI-HTTP server. For a more fully-featured Eventlet-capable interface, see also [Spawning](http://pypi.python.org/pypi/Spawning/). """ # Instantiate the server with a bound port and with our application. server(listen(host, int(port)), application)
def run_server(conf, logger, sock, global_conf=None):
# Ensure TZ environment variable exists to avoid stat('/etc/localtime') on
# some platforms. This locks in reported times to UTC.
os.environ['TZ'] = 'UTC+0'
time.tzset()
wsgi.WRITE_TIMEOUT = int(conf.get('client_timeout') or 60)
eventlet.hubs.use_hub(get_hub())
eventlet_debug = config_true_value(conf.get('eventlet_debug', 'no'))
eventlet.debug.hub_exceptions(eventlet_debug)
wsgi_logger = NullLogger()
if eventlet_debug:
# let eventlet.wsgi.server log to stderr
wsgi_logger = None
# utils.LogAdapter stashes name in server; fallback on unadapted loggers
if not global_conf:
if hasattr(logger, 'server'):
log_name = logger.server
else:
log_name = logger.name
global_conf = {'log_name': log_name}
# loadapp方法从proxy-server.conf中加载其中的app，
# 调用其中的app_factory方法实例化功能类(Application)
# conf = {"user": "******", "allow_account_management": "true",
# "bind_port": "8080", "__name__": "proxy-server",
# "__file__": "/etc/swift/proxy-server.conf",
# "account_autocreate": "true", "here": "/etc/swift"}
# global_conf = {"log_name": "proxy-server"}
app = loadapp(conf['__file__'], global_conf=global_conf)
max_clients = int(conf.get('max_clients', '1024')) # dict.get(key, default=None),key不在，则返回默认值
pool = RestrictedGreenPool(size=max_clients)
# Select which protocol class to use (normal or one expecting PROXY
# protocol)
if config_true_value(conf.get('require_proxy_protocol', 'no')):
protocol_class = SwiftHttpProxiedProtocol
else:
protocol_class = SwiftHttpProtocol
server_kwargs = {
'custom_pool': pool,
'protocol': protocol_class,
# Disable capitalizing headers in Eventlet. This is necessary for
# the AWS SDK to work with s3api middleware (it needs an "ETag"
# header; "Etag" just won't do).
'capitalize_response_headers': False,
}
# server：从提供的服务器套接字启动一个的WSGI服务器处理请求；这个方法将会一直循环；
# 当服务退出之后，sock对象将会关闭；但是底层描述符将会继续开放；
try:
wsgi.server(sock, app, wsgi_logger, **server_kwargs)
except socket.error as err:
if err[0] != errno.EINVAL:
raise
# 等待池子中的所有 greenthreads 完成工作
pool.waitall()
def start(self):
explorer_worker_handle = eventlet.spawn(self.explorer.worker)
flask_app = Flask(self.__class__.__name__)
flask_app.debug = True
self.regist_flask_routes(flask_app)
sock = eventlet.listen(("localhost", self.listen_port))
wsgi.server(sock, flask_app)
explorer_worker_handle.wait()
raise RuntimeError("should not reach here! (TODO: support shutdown on inspection termination)")
def _listen(self):
try:
wsgi.server(eventlet.listen((self.interface, self.port)), self, max_size=10240)
except Exception, e:
import sys
import traceback
print >>sys.stderr, "*** ERROR", e
traceback.print_tb(sys.exc_info()[2])
sys.exit(1)
def run_server(self):
"""
to run the server
"""
wsgi.server(eventlet.listen(('', 8090)), hello_world)
pass
def main(argv):
app.config.from_pyfile('face.cfg')
app.teardown_appcontext(db.close_connection)
rpc.init(app)
if app.config['DEBUG']:
app.run(port=8000, debug=True)
else:
wsgi.server(eventlet.listen(('', 8000)), app)
def serve_eventlet(self):
"""
Eventlet server, fast async, for production use
:return:
"""
listener = eventlet.listen(('0.0.0.0', self.HTTP_PORT))
logger.info('Starting Eventlet listener %s for Flask %s' %
(listener, self.flask))
wsgi.server(listener, self.flask, **self.wsgi_options())
def main():
server.setup_common(possible_topdir, 'API')
app = server.make_app()
server.setup_sahara_api(app, 'distributed')
wsgi.server(eventlet.listen((cfg.CONF.host, cfg.CONF.port), backlog=500),
app, log=logging.WritableLogger(LOG), debug=False)
def run_server(self):
"""Run a WSGI server."""
self.pool = eventlet.GreenPool(size=self.threads)
wsgi.server(self.sock,
self.application,
custom_pool=self.pool,
log=loggers.WritableLogger(LOG),
debug=False)
self.pool.waitall()
def _run_server():
host = cfg.CONF.api.host
port = cfg.CONF.api.port
LOG.info('(PID=%s) ST2 API is serving on http://%s:%s.', os.getpid(), host,
port)
wsgi.server(eventlet.listen((host, port)), app.setup_app())
return 0
def eventlet_server(conf=None):
global lb_conf
lb_conf = conf
# Default extra mock port is 9999
port = lb_conf.get('extra.mock.port') if lb_conf.get('extra.mock.port') else 9999
logger.info(f'ExtraMockServer start on {port}')
wsgi.server(eventlet.listen(('', port)), app.wsgi_app)
def run_server(self):
"""Run a WSGI server."""
self.pool = eventlet.GreenPool(size=self.threads)
wsgi.server(self.sock,
self.application,
custom_pool=self.pool,
log=loggers.WritableLogger(LOG),
debug=False)
self.pool.waitall()
def setup(addr, client_addrs=[], server_ports=[]):
server = Server()
for c_host, c_port in client_addrs:
server.setup_client(c_host, c_port)
for s_port in server_ports:
server.setup_server(s_port)
eventlet.spawn(server.run)
sock = eventlet.listen(addr)
wsgi.server(sock, server.wsgi_application)
def run_server(self):
"""
to run the server
"""
wsgi.server(eventlet.listen(('', 8090)), hello_world)
pass
def run_server(conf, logger, sock, global_conf=None):
# Ensure TZ environment variable exists to avoid stat('/etc/localtime') on
# some platforms. This locks in reported times to the timezone in which
# the server first starts running in locations that periodically change
# timezones.
os.environ['TZ'] = time.strftime("%z", time.gmtime())
wsgi.HttpProtocol.default_request_version = "HTTP/1.0"
# Turn off logging requests by the underlying WSGI software.
wsgi.HttpProtocol.log_request = lambda *a: None
# Redirect logging other messages by the underlying WSGI software.
wsgi.HttpProtocol.log_message = \
lambda s, f, *a: logger.error('ERROR WSGI: ' + f % a)
wsgi.WRITE_TIMEOUT = int(conf.get('client_timeout') or 60)
eventlet.hubs.use_hub(get_hub())
# NOTE(sileht):
# monkey-patching thread is required by python-keystoneclient;
# monkey-patching select is required by oslo.messaging pika driver
# if thread is monkey-patched.
eventlet.patcher.monkey_patch(all=False,
socket=True,
select=True,
thread=True)
eventlet_debug = config_true_value(conf.get('eventlet_debug', 'no'))
eventlet.debug.hub_exceptions(eventlet_debug)
wsgi_logger = NullLogger()
if eventlet_debug:
# let eventlet.wsgi.server log to stderr
wsgi_logger = None
# utils.LogAdapter stashes name in server; fallback on unadapted loggers
if not global_conf:
if hasattr(logger, 'server'):
log_name = logger.server
else:
log_name = logger.name
global_conf = {'log_name': log_name}
app = loadapp(conf['__file__'], global_conf=global_conf)
max_clients = int(conf.get('max_clients', '1024'))
pool = RestrictedGreenPool(size=max_clients)
try:
# Disable capitalizing headers in Eventlet if possible. This is
# necessary for the AWS SDK to work with swift3 middleware.
argspec = inspect.getargspec(wsgi.server)
if 'capitalize_response_headers' in argspec.args:
wsgi.server(sock,
app,
wsgi_logger,
custom_pool=pool,
capitalize_response_headers=False)
else:
wsgi.server(sock, app, wsgi_logger, custom_pool=pool)
except socket.error as err:
if err[0] != errno.EINVAL:
raise
pool.waitall()
