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, 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 main():
cfg = Configuration()
init_logging(cfg)
init_k8s_client(cfg)
log = logging.getLogger(__name__)
try:
log.info("fiaas-skipper starting with configuration {!r}".format(cfg))
cluster = Cluster()
if cfg.release_channel_metadata:
log.debug("!!Using hardcoded release channel metadata {!r}".format(
cfg.release_channel_metadata))
spec = _read_file(cfg.release_channel_metadata_spec)
release_channel_factory = FakeReleaseChannelFactory(
json.loads(cfg.release_channel_metadata), spec)
else:
release_channel_factory = ReleaseChannelFactory(cfg.baseurl)
spec_config_extension = None
if os.path.isfile(cfg.spec_file_override):
try:
spec_config_extension = _load_spec_config(
cfg.spec_file_override)
log.debug("Loaded spec config extension from file {!r}".format(
cfg.spec_file_override))
except yaml.YAMLError:
log.exception(
"Unable to load spec config extension file {!r} using defaults"
.format(cfg.spec_file_override))
deployer = CrdDeployer(cluster=cluster,
release_channel_factory=release_channel_factory,
bootstrap=CrdBootstrapper(),
spec_config_extension=spec_config_extension)
# Do period checking of deployment status across all namespaces
status_tracker = StatusTracker(cluster=cluster,
application=FiaasApplication,
interval=cfg.status_update_interval)
status_tracker.start()
if not cfg.disable_autoupdate:
updater = AutoUpdater(
release_channel_factory=release_channel_factory,
deployer=deployer,
status=status_tracker)
updater.start()
else:
log.debug("Auto updates disabled")
webapp = create_webapp(deployer, cluster, release_channel_factory,
status_tracker)
log = LoggingLogAdapter(LOG, logging.DEBUG)
error_log = LoggingLogAdapter(LOG, logging.ERROR)
# Run web-app in main thread
http_server = WSGIServer(("", cfg.port),
webapp,
log=log,
error_log=error_log)
http_server.serve_forever()
except BaseException:
log.exception(
"General failure! Inspect traceback and make the code better!")
def run(self):
self.app.logger.info('===== Starting {} ====='.format(self.app_id))
self.app.logger.debug(f'--> registered routes:\n {self.app.url_map}')
if self.development:
self.app.logger.info(f'--> initialising in development mode...')
self.app.run(debug=self.development, threaded=True)
# todo: make the threading and deployment configurable
# self.app.run(debug=self.development, processes=8)
else:
try:
from gevent.pywsgi import WSGIServer, LoggingLogAdapter
port = self.cfg_engine.get('appkernel.server.port', 5000)
binding_address = self.cfg_engine.get(
'appkernel.server.address', '')
backlog = self.cfg_engine.get('appkernel.server.backlog', 256)
logging_adapter = LoggingLogAdapter(self.app.logger)
self.http_server = WSGIServer((binding_address, port),
application=self.app,
backlog=backlog,
log=logging_adapter,
error_log=logging_adapter)
shutdown_timeout = self.cfg_engine.get(
'appkernel.server.shutdown_timeout', 10)
self.app.logger.info(
f'--> starting production mode |host: {binding_address}|port: {port}|backlog: {backlog}'
)
print(f'=== starting server ===')
self.http_server.serve_forever(stop_timeout=shutdown_timeout)
except ImportError:
self.app.logger.warning(
'--> falling back to the builtin development server (since gevent is missing / issue: pip install gevent'
)
self.app.run(debug=self.development, threaded=True)
def make_simple_healthchecker(
listener: socket.socket,
callback: Optional[HealthcheckCallback] = None) -> WSGIServer:
return WSGIServer(
listener=listener,
application=HealthcheckApp(callback),
log=LoggingLogAdapter(logger, level=logging.DEBUG),
)
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
def make_server(config, listener, app):
"""Make a Gevent server for WSGI apps."""
max_concurrency = int(config.get("max_concurrency", 0)) or None
stop_timeout = int(config.get("stop_timeout", 0))
handler = config.get("handler", None)
pool = Pool(size=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 handler:
kwargs["handler_class"] = _load_factory(handler, default_name=None)
server = WSGIServer(listener,
application=app,
spawn=pool,
log=log,
**kwargs)
server.stop_timeout = stop_timeout
return server
def start(host="127.0.0.1", port=80, key=None, cert=None):
"""
Start RPC server. This function is blocking.
Start by default unsecure web server
You can configure SSL server specifying key and cert parameters
Args:
host (string): host (default computer is accessible on localt network)
port (int): port to listen to (by default is standart HTTP port 80)
key (string): SSL key file
cert (string): SSL certificate file
"""
global app, context
# populate some stuff at startup
context.modules["devices"].get_devices()
context.modules["updates"].get_status()
try:
if key is not None and len(key) > 0 and cert is not None and len(
cert) > 0:
# start HTTPS server
context.main_logger.info("Starting HTTPS server on %s:%d" %
(host, port))
server_logger = LoggingLogAdapter(context.main_logger,
logging.ERROR)
server = pywsgi.WSGIServer(
(host, port),
app,
keyfile=key,
certfile=cert,
log=server_logger,
handler_class=WebSocketHandler,
)
server.serve_forever()
else:
# start HTTP server
context.main_logger.info("Starting HTTP server on %s:%d" %
(host, port))
server_logger = LoggingLogAdapter(context.main_logger,
logging.ERROR)
server = pywsgi.WSGIServer((host, port),
app,
log=server_logger,
handler_class=WebSocketHandler)
server.serve_forever()
except KeyboardInterrupt:
# user stops raspiot
pass
except UnicodeDecodeError:
# maybe unsupported character in hostname
# this is a unfixed bug in python https://bugs.python.org/issue9377
# topic about it (no solution @ 2019/12/12)
# https://stackoverflow.com/questions/23109244/unicodedecodeerror-with-runserver
context.main_logger.exception(
"HTTP server failed to start because computer hostname seems to have unsupported characters. Please use only ASCII."
)
context.crash_report.report_exception()
except:
# unhandled exception
context.main_logger.exception("HTTP server failed to start:")
context.crash_report.report_exception()
finally:
# close server properly
if server and not server.closed:
server.close()
import face_recognizer.endpoints.__root__
import face_recognizer.endpoints.get_images
import face_recognizer.endpoints.upload_photo
import face_recognizer.endpoints.face_similarity
import face_recognizer.endpoints.face_similarity_b64
import face_recognizer.endpoints.code_validator
import face_recognizer.endpoints.find_visitor_by_face
import face_recognizer.endpoints.approve_request
# Serve Static Files
@app.route('/static/<path:path>')
def serve_static_file(path):
return send_from_directory(config.STATIC_DIR, path)
logger.info("All API endpoints initialized. ")
server_logger = LoggingLogAdapter(logger)
def start_http_server():
'''
Start the API server over HTTP
'''
logger.info("Starting HTTP Server")
http_server = WSGIServer((config.HOST, int(config.PORT)),
app,
log=server_logger,
error_log=server_logger)
http_server.serve_forever()
from api import users_blueprint
from app import app
from app import db
# Create log directory
pathlib.Path(config.LOG_PATH).mkdir(parents=True, exist_ok=True)
logbook.StreamHandler(sys.stdout).push_application()
logbook.RotatingFileHandler(config.LOGFILE, max_size=52428800,
bubble=True).push_application()
logbook.compat.redirect_logging(set_root_logger_level=False)
logging.root.setLevel(config.LOGLEVEL)
logger = logbook.Logger('[SERVER]', getattr(logbook, config.LOGLEVEL))
wsgi_logger = LoggingLogAdapter(logging.getLogger('wsgi'), level=logging.DEBUG)
wsgi_server = WSGIServer((config.API_IP, config.API_PORT),
app,
log=wsgi_logger,
error_log=wsgi_logger)
app.register_blueprint(users_blueprint)
@app.errorhandler(404)
def page_not_found(e):
return jsonify(error=404, text=str(e)), 404
@app.errorhandler(500)
def internal_server_error(e):
