def make_server(server_config: Dict[str, str], listener: socket.socket,
app: Any) -> StreamServer:
# pylint: disable=maybe-no-member
cfg = config.parse_config(
server_config,
{
"max_concurrency":
config.Optional(config.Integer),
"stop_timeout":
config.Optional(config.TimespanWithLegacyFallback,
default=datetime.timedelta(seconds=10)),
},
)
if cfg.max_concurrency is not None:
logger.warning(
"The max_concurrency setting is deprecated for Thrift servers. See https://git.io/Jeywc."
)
pool = Pool(size=cfg.max_concurrency)
server = GeventServer(processor=app, listener=listener, spawn=pool)
server.stop_timeout = cfg.stop_timeout.total_seconds()
runtime_monitor.start(server_config, app, pool)
return server
def make_server(server_config, listener, app):
"""Make a gevent server for WSGI apps."""
# pylint: disable=maybe-no-member
cfg = config.parse_config(
server_config,
{
"handler": config.Optional(config.String, default=None),
"max_concurrency": config.Integer,
"stop_timeout": config.Optional(config.Integer, default=0),
},
)
pool = Pool(size=cfg.max_concurrency)
log = LoggingLogAdapter(logger, level=logging.DEBUG)
kwargs = {}
if gevent.version_info[:2] >= (1, 1): # error_log is new in 1.1
kwargs["error_log"] = LoggingLogAdapter(logger, level=logging.ERROR)
if cfg.handler:
kwargs["handler_class"] = _load_factory(cfg.handler, default_name=None)
server = WSGIServer(listener, application=app, spawn=pool, log=log, **kwargs)
server.stop_timeout = cfg.stop_timeout
runtime_monitor.start(server_config, app, pool)
return server
def make_server(server_config: Dict[str, str], listener: socket.socket,
app: QueueConsumerFactory) -> QueueConsumerServer:
"""Make a queue consumer server for long running queue consumer apps.
If you require that you process messages in-order, your handler is heavily CPU
bound, or you don't do any IO when handling a message you should restrict
max_concurrency to 1.
"""
cfg = baseplate.lib.config.parse_config(
server_config,
{
"max_concurrency":
baseplate.lib.config.Integer,
"stop_timeout":
baseplate.config.Optional(baseplate.config.Timespan,
default=datetime.timedelta(seconds=30)),
},
)
runtime_monitor.start(server_config, app, pool=None)
return QueueConsumerServer.new(
consumer_factory=app,
max_concurrency=cfg.max_concurrency,
listener=listener,
stop_timeout=cfg.stop_timeout,
)
def make_server(server_config: Dict[str, str], listener: socket.socket,
app: Any) -> StreamServer:
"""Make a gevent server for WSGI apps."""
# pylint: disable=maybe-no-member
cfg = config.parse_config(
server_config,
{
"handler": config.Optional(config.String, default=None),
"max_concurrency": config.Integer,
"stop_timeout": config.Optional(config.Integer, default=0),
},
)
pool = Pool(size=cfg.max_concurrency)
log = LoggingLogAdapter(logger, level=logging.DEBUG)
kwargs: Dict[str, Any] = {}
if cfg.handler:
kwargs["handler_class"] = _load_factory(cfg.handler, default_name=None)
server = WSGIServer(
listener,
application=app,
spawn=pool,
log=log,
error_log=LoggingLogAdapter(logger, level=logging.ERROR),
**kwargs,
)
server.stop_timeout = cfg.stop_timeout
runtime_monitor.start(server_config, app, pool)
return server
def make_server(server_config: Dict[str, str], listener: socket.socket,
app: Any) -> StreamServer:
# pylint: disable=maybe-no-member
cfg = config.parse_config(
server_config,
{
"max_concurrency": config.Integer,
"stop_timeout": config.Optional(config.Integer, default=0),
},
)
pool = Pool(size=cfg.max_concurrency)
server = GeventServer(processor=app, listener=listener, spawn=pool)
server.stop_timeout = cfg.stop_timeout
runtime_monitor.start(server_config, app, pool)
return server
def make_server(server_config: Dict[str, str], listener: socket.socket,
app: Any) -> StreamServer:
# pylint: disable=maybe-no-member
cfg = config.parse_config(
server_config,
{
"max_concurrency":
config.Integer,
"stop_timeout":
config.Optional(config.TimespanWithLegacyFallback,
default=datetime.timedelta(seconds=10)),
},
)
pool = Pool(size=cfg.max_concurrency)
server = GeventServer(processor=app, listener=listener, spawn=pool)
server.stop_timeout = cfg.stop_timeout.total_seconds()
runtime_monitor.start(server_config, app, pool)
return server
def make_server(server_config: Dict[str, str], listener: socket.socket,
app: Any) -> StreamServer:
"""Make a gevent server for WSGI apps."""
# pylint: disable=maybe-no-member
cfg = config.parse_config(
server_config,
{
"handler":
config.Optional(config.String, default=None),
"max_concurrency":
config.Optional(config.Integer),
"stop_timeout":
config.Optional(config.TimespanWithLegacyFallback,
default=datetime.timedelta(seconds=10)),
},
)
if cfg.max_concurrency is not None:
raise Exception(
"The max_concurrency setting is not allowed for WSGI servers. See https://git.io/Jeywc."
)
pool = Pool()
log = LoggingLogAdapter(logger, level=logging.DEBUG)
kwargs: Dict[str, Any] = {}
if cfg.handler:
kwargs["handler_class"] = _load_factory(cfg.handler, default_name=None)
server = WSGIServer(
listener,
application=app,
spawn=pool,
log=log,
error_log=LoggingLogAdapter(logger, level=logging.ERROR),
**kwargs,
)
server.stop_timeout = cfg.stop_timeout.total_seconds()
runtime_monitor.start(server_config, app, pool)
return server
