def main(global_config, **settings):
""" WSGI-Server erzeugen und konfigurieren. """
# extrat all flask.* configuration items
flaskConfig = pasteToFlaskConfig(global_config, settings)
DEBUG = flaskConfig.get('DEBUG', '0') in ['1', 'on', 'true']
VERBOSE = int(global_config.get('STARTUP_VERBOSE', 0))
# create app instance
connexionApp = connexion.App("{{cookiecutter.project_name}}", debug=DEBUG, swagger_ui=True)
flaskApp = connexionApp.app
# configure
flaskApp.config.update(flaskConfig)
cloudFoundryfyConfig(flaskApp.config)
# Rest-Endpoint CF Spring Actuator like Metadaten (Definition im sub-package api.actuator)
apiFile = pkg_resources.resource_filename(__name__, 'schema/actuator.yml')
connexionApp.add_api(apiFile, strict_validation=False, validate_responses=True,
resolver=connexion.RestyResolver('%s.api.actuator' % (__package__)),
base_path='/cloudfoundryapplication')
# Restendpoint App Version 1 (Definition im sub-package api)
apiFile = pkg_resources.resource_filename(__name__, 'schema/app_v1.yml')
connexionApp.add_api(apiFile, strict_validation=True, validate_responses=True,
resolver=connexion.RestyResolver('%s.api' % (__package__)))
if VERBOSE > 0:
print(yaml.dump(flaskApp.config))
if DEBUG:
from flask_debugtoolbar import DebugToolbarExtension
toolbar = DebugToolbarExtension()
toolbar.init_app(flaskApp)
{% if cookiecutter.use_reldb.startswith('y') %}
# proaktive Initialisierung der Datenbank (entfernen -> lazy)
from .model import getDb
with flaskApp.app_context():
db = getDb()
{%- endif -%}
{% if cookiecutter.use_ui.startswith('y') %}
# simple web-ui page without swagger
from .ui.hello import helloPage
flaskApp.register_blueprint(helloPage)
{%- endif -%}
return flaskApp
def run_forever(self):
app = connexion.FlaskApp(__name__)
init_jwt(app.app)
@app.app.teardown_appcontext
def shutdown_session(exception=None):
db_session.remove()
app.add_api(API.SPEC_FILE,
arguments={
'title': API.TITLE,
'url_prefix': API.URL_PREFIX,
'RESPONSES': API.RESPONSES
},
resolver=connexion.RestyResolver(API.IMPL_LOCATION),
strict_validation=True)
CORS(app.app)
log.info('[⚙] Starting API server with {} backend'.format(
API_SERVER.BACKEND))
URL = '{schema}://{host}:{port}/{url_prefix}/ui/'.format(
schema=API.URL_SCHEMA,
host=API.URL_HOSTNAME,
port=API.URL_PORT,
url_prefix=API.URL_PREFIX)
log.info(
green('[✔] API documentation (Swagger UI) available at: {}'.format(
URL)))
app.run(server=API_SERVER.BACKEND,
host=API_SERVER.HOST,
port=API_SERVER.PORT,
debug=API_SERVER.DEBUG,
log=APILogger)
def create_app(specs):
"""Create reposcan app."""
init_logging()
LOGGER.info("Starting (version %s).", VMAAS_VERSION)
sync_interval = int(os.getenv('REPOSCAN_SYNC_INTERVAL_MINUTES', "360")) * 60000
if sync_interval > 0:
PeriodicCallback(periodic_sync, sync_interval).start()
else:
LOGGER.info("Periodic syncing disabled.")
ws_handler = ReposcanWebsocket()
def terminate(*_):
"""Trigger shutdown."""
LOGGER.info("Signal received, stopping application.")
# Kill asyncio ioloop
IOLoop.instance().add_callback_from_signal(ws_handler.stop)
# Kill background pool
SyncTask.cancel()
for sig in KILL_SIGNALS:
signal.signal(sig, terminate)
ws_handler.websocket_reconnect()
ws_handler.reconnect_callback = PeriodicCallback(ws_handler.websocket_reconnect,
WEBSOCKET_RECONNECT_INTERVAL * 1000)
ws_handler.reconnect_callback.start()
app = connexion.App(__name__, options={
'swagger_ui': True,
'openapi_spec_path': '/openapi.json'
})
# Response validation is disabled due to returing streamed response in GET /pkgtree
# https://github.com/zalando/connexion/pull/467 should fix it
for route, spec in specs.items():
app.add_api(spec, resolver=connexion.RestyResolver('reposcan'),
validate_responses=False,
strict_validation=True,
base_path=route,
arguments={"vmaas_version": VMAAS_VERSION}
)
@app.app.route('/metrics', methods=['GET'])
def metrics(): # pylint: disable=unused-variable
# /metrics API shouldn't be visible in the API documentation,
# hence it's added here in the create_app step
return generate_latest(), 200, {'Content-Type': 'text/plain; charset=utf-8'}
@app.app.after_request
def set_headers(response): # pylint: disable=unused-variable
response.headers["Access-Control-Allow-Origin"] = "*"
response.headers["Access-Control-Allow-Headers"] = "Content-Type"
return response
return app
def create_app():
connexion_app = connexion.App(__name__, specification_dir="specs/")
connexion_api = connexion_app.add_api(
resolver=connexion.RestyResolver("jboard.viewsets"),
specification="v1.yaml",
strict_validation=True,
validate_responses=True,
)
flask_app = connexion_app.app
flask_app.config["JSON_SORT_KEYS"] = False
flask_app.config["spec"] = connexion_api.specification
return flask_app
def client():
app = connexion.FlaskApp(__name__)
app.add_api('../../tensorhive/api/' + API.SPEC_FILE,
arguments={
'title': API.TITLE,
'url_prefix': API.URL_PREFIX,
'RESPONSES': API.RESPONSES
},
resolver=connexion.RestyResolver(API.IMPL_LOCATION),
strict_validation=True)
CORS(app.app)
return app.app.test_client()
from jinja2 import Environment, PackageLoader
from filters import get_all_apis_router, get_entity_fields
SWAGGER_PATH = "swagger/"
API_PATH = 'endpoints'
app = connexion.App(__name__, specification_dir=SWAGGER_PATH)
application = app.app
application.url_map.strict_slashes = False
_env = Environment(loader=PackageLoader('swagger'))
swagger_string = _env.get_template("main.yaml").render(
lstrip=False,
api=get_all_apis_router("api", SWAGGER_PATH),
schemas=get_all_apis_router("schemas", SWAGGER_PATH),
**get_entity_fields(),
)
import pprint
pprint.pprint(swagger_string)
specification = yaml.safe_load(swagger_string)
app.add_api(
specification,
resolver=connexion.RestyResolver(API_PATH),
options={"swagger_ui": True},
)
if __name__ == '__main__':
app.run()
@app.route(api_url + '/users', methods=['POST'])
@cross_origin(origin='*')
def create_user():
id = request.form['id']
name = request.form['name']
if id and name and request.method == "POST":
users = db.Users.find_one({'id': id})
if users is not None:
resp = jsonify('User already exists')
resp.status_code = 402
return resp
else:
db.Users.insert_one({'id': id, 'name': name})
resp = jsonify('User added successfully!')
resp.status_code = 201
return resp
else:
resp = jsonify('Bad Request')
resp.status_code = 400
return resp
if __name__ == "__main__":
app.add_api('my_api.yaml', resolver=connexion.RestyResolver('api'))
app.run(port=3000, debug=True)
def create_app():
"""Create VmaaS application and servers"""
init_logging()
LOGGER.info("Starting (version %s).", VMAAS_VERSION)
LOGGER.info('Hotcache enabled: %s', os.getenv("HOTCACHE_ENABLED", "YES"))
with open('webapp.spec.yaml', 'rb') as specfile:
SPEC = yaml.safe_load(specfile) # pylint: disable=invalid-name
@web.middleware
async def timing_middleware(request, handler, **kwargs):
""" Middleware that handles timing of requests"""
start_time = time.time()
if asyncio.iscoroutinefunction(handler):
res = await handler(request, **kwargs)
else:
res = handler(request, **kwargs)
duration = (time.time() - start_time)
# (0) /(1) /(2) /(3)
# /api /v1 /updates
const_path = '/'.join(request.path.split('/')[:4])
REQUEST_TIME.labels(request.method, const_path).observe(duration)
REQUEST_COUNTS.labels(request.method, const_path, res.status).inc()
return res
@web.middleware
async def error_formater(request, handler, **kwargs):
#pylint: disable=broad-except
def build_error(detail, status):
errors = {"detail": detail, "status": status}
return {"errors": [errors]}
res = await handler(request, **kwargs)
try:
if res.status >= 400:
original_error = loads(res.body)
better_error = build_error(original_error["detail"], original_error["status"])
return web.json_response(better_error, status=res.status)
return res
except TypeError: # The error response is not made by connexion
better_error = build_error(original_error, res.status)
return web.json_response(better_error, status=res.status)
except Exception as _:
LOGGER.exception(_)
return web.json_response(build_error("Internal server error", 500), status=500)
app = connexion.AioHttpApp(__name__, options={
'swagger_ui': True,
'openapi_spec_path': '/openapi.json',
'middlewares': [error_formater,
timing_middleware]
})
def metrics(request, **kwargs): #pylint: disable=unused-argument
"""Provide current prometheus metrics"""
# /metrics API shouldn't be visible in the API documentation,
# hence it's added here in the create_app step
return web.Response(text=generate_latest().decode('utf-8'))
async def on_prepare(request, response): #pylint: disable=unused-argument
"""Hook for preparing new responses"""
response.headers["Access-Control-Allow-Origin"] = "*"
response.headers["Access-Control-Allow-Headers"] = "Content-Type"
app.app.on_response_prepare.append(on_prepare)
app.app.router.add_get("/metrics", metrics)
app.add_api(SPEC, resolver=connexion.RestyResolver('app'),
validate_responses=False,
strict_validation=False,
base_path='/api',
pass_context_arg_name='request'
)
BaseHandler.db_cache = Cache()
load_cache_to_apis()
return app
def create_app():
"""Create VmaaS application and servers"""
init_logging()
LOGGER.info("Starting (version %s).", VMAAS_VERSION)
with open('webapp.spec.yaml', 'rb') as specfile:
SPEC = yaml.safe_load(specfile) # pylint: disable=invalid-name
SPEC['info']['version'] = VMAAS_VERSION
@web.middleware
async def timing_middleware(request, handler, **kwargs):
""" Middleware that handles timing of requests"""
start_time = time.time()
if asyncio.iscoroutinefunction(handler):
res = await handler(request, **kwargs)
else:
res = handler(request, **kwargs)
duration = (time.time() - start_time)
# (0) /(1) /(2) /(3)
# /api /v1 /updates
const_path = '/'.join(request.path.split('/')[:4])
REQUEST_TIME.labels(request.method, const_path).observe(duration)
REQUEST_COUNTS.labels(request.method, const_path, res.status).inc()
return res
@web.middleware
async def gzip_middleware(request, handler, **kwargs):
""" Middleware that compress response using gzip"""
res = await handler(request, **kwargs)
header = 'Accept-Encoding'
if header in request.headers and "gzip" in request.headers[header]:
gzipped_body = gzip.compress(res.body,
compresslevel=GZIP_COMPRESS_LEVEL)
res.body = gzipped_body
res.headers["Content-Encoding"] = "gzip"
return res
@web.middleware
async def error_handler(request, handler, **kwargs):
def format_error(detail, status):
res = {}
res["type"] = "about:blank"
res["detail"] = detail
res["status"] = status
return res
res = await handler(request, **kwargs)
if res.status >= 400:
body = loads(res.body)
better_error = format_error(body, res.status)
return web.json_response(better_error, status=res.status)
return res
middlewares = []
if GZIP_RESPONSE_ENABLE:
middlewares.append(gzip_middleware)
middlewares.extend([error_handler, timing_middleware])
app = connexion.AioHttpApp(__name__,
options={
'swagger_ui': True,
'openapi_spec_path': '/openapi.json',
'middlewares': middlewares
})
def metrics(request, **kwargs): # pylint: disable=unused-argument
"""Provide current prometheus metrics"""
# /metrics API shouldn't be visible in the API documentation,
# hence it's added here in the create_app step
return web.Response(text=generate_latest().decode('utf-8'))
async def on_prepare(request, response): # pylint: disable=unused-argument
"""Hook for preparing new responses"""
response.headers["Access-Control-Allow-Origin"] = "*"
response.headers["Access-Control-Allow-Headers"] = "Content-Type"
app.app.on_response_prepare.append(on_prepare)
app.app.router.add_get("/metrics", metrics)
app.add_api(SPEC,
resolver=connexion.RestyResolver('app'),
validate_responses=False,
strict_validation=False,
base_path='/api',
pass_context_arg_name='request')
BaseHandler.db_cache = Cache()
load_cache_to_apis()
return app
from typing import Any, Dict
from pathlib import Path
import sentry_sdk
import os
from libs.database.engine import set_session_destroyer
from migration import migrate # 지우지마
if os.environ.get('SY_STAGE', '') == 'PRODUCTION':
sentry_sdk.init("https://[email protected]/5233605")
app = connexion.App(__name__, specification_dir='admin/spec/', options={'swagger_path': swagger_ui_3_path})
set_session_destroyer(app.app)
CORS(app.app)
def get_bundled_specs(main_file: Path) -> Dict[str, Any]:
parser = prance.ResolvingParser(str(main_file.absolute()),
lazy = True, strict = True)
parser.parse()
return parser.specification
app.add_api(get_bundled_specs(Path("admin/spec/main.yaml")),
resolver = connexion.RestyResolver("cms_rest_api"))
# base path 를 넣으면 GKE 에서도 제대로 될 거 같음!
# https://connexion.readthedocs.io/en/latest/routing.html
def create_app(specs):
"""Create VmaaS application and servers"""
LOGGER.info("Starting (version %s).", VMAAS_VERSION)
@web.middleware
async def timing_middleware(request, handler, **kwargs):
""" Middleware that handles timing of requests"""
start_time = time.time()
if asyncio.iscoroutinefunction(handler):
res = await handler(request, **kwargs)
else:
res = handler(request, **kwargs)
duration = (time.time() - start_time)
# (0) /(1) /(2) /(3)
# /api /v1 /updates
const_path = '/'.join(request.path.split('/')[:4])
REQUEST_TIME.labels(request.method, const_path).observe(duration)
REQUEST_COUNTS.labels(request.method, const_path, res.status).inc()
return res
@web.middleware
async def gzip_middleware(request, handler, **kwargs):
""" Middleware that compress response using gzip"""
res = await handler(request, **kwargs)
header = 'Accept-Encoding'
try:
if res.body is not None and header in request.headers and "gzip" in request.headers[
header]:
gzipped_body = gzip.compress(res.body,
compresslevel=GZIP_COMPRESS_LEVEL)
res.body = gzipped_body
res.headers["Content-Encoding"] = "gzip"
return res
except (TypeError, AttributeError):
LOGGER.warning("unable to gzip response '%s'", request.path)
return res
@web.middleware
async def error_handler(request, handler, **kwargs):
def format_error(detail, status):
res = {}
res["type"] = "about:blank"
res["detail"] = detail
res["status"] = status
return res
res = await handler(request, **kwargs)
if res.status >= 400 and res.body:
body = loads(res.body)
better_error = format_error(body, res.status)
return web.json_response(better_error, status=res.status)
return res
middlewares = []
if GZIP_RESPONSE_ENABLE:
middlewares.append(gzip_middleware)
middlewares.extend([error_handler, timing_middleware])
app = connexion.AioHttpApp(__name__,
options={
'swagger_ui': True,
'openapi_spec_path': '/openapi.json',
'middlewares': middlewares
})
def metrics(request, **kwargs): # pylint: disable=unused-argument
"""Provide current prometheus metrics"""
# /metrics API shouldn't be visible in the API documentation,
# hence it's added here in the create_app step
return web.Response(text=generate_latest().decode('utf-8'))
def dummy_200(request, **kwargs): # pylint: disable=unused-argument
"""Dummy endpoint returning 200"""
return web.Response()
async def on_prepare(request, response): # pylint: disable=unused-argument
"""Hook for preparing new responses"""
response.headers["Access-Control-Allow-Origin"] = "*"
response.headers["Access-Control-Allow-Headers"] = "Content-Type"
response.headers['Access-Control-Allow-Methods'] = 'GET, OPTIONS, POST'
app.app.on_response_prepare.append(on_prepare)
app.app.router.add_get("/metrics", metrics)
app.app.router.add_get("/healthz", HealthHandler.get)
app.app.router.add_route("OPTIONS", "/api/v3/cves", dummy_200)
for route, spec in specs.items():
app.add_api(spec,
resolver=connexion.RestyResolver('app'),
validate_responses=False,
strict_validation=False,
base_path=route,
pass_context_arg_name='request',
arguments={'vmaas_version': VMAAS_VERSION})
BaseHandler.db_cache = Cache()
load_cache_to_apis()
return app
import connexion
from api import config
from api.db import DB
app = connexion.FlaskApp(__name__)
app.add_api(
"swagger.yaml",
resolver=connexion.RestyResolver("customer_review.api"),
strict_validation=True,
validate_responses=True,
)
app = app.app
app.config.update(**config.MYSQL.params())
DB.init_app(app)
if __name__ == '__main__':
app.run(debug=True, host='0.0.0.0')
import connexion
app = connexion.FlaskApp(__name__)
app.add_api('swagger.yml',
resolver=connexion.RestyResolver('primer.api'),
strict_validation=True,
validate_responses=True)
if __name__ == '__main__':
app.run()
from models.db import db
import models.utils as db_utils
APP_DIR = '/home/scairns/code/bairng/server/app/openapi'
OPENAPI_DIR = APP_DIR
SQLALCHEMY_DATABASE_URI = 'sqlite:////tmp/bairng_server.db'
connex_app = connexion.FlaskApp(__name__, specification_dir=OPENAPI_DIR)
app = connex_app.app
app.config['SQLALCHEMY_DATABASE_URI'] = SQLALCHEMY_DATABASE_URI
app.secret_key = os.environ.get('BAIRNG_SECRET_KEY') #'dev' in dev
login_manager = LoginManager()
login_manager.init_app(app)
connex_app.add_api('bairng_api.yaml', resolver=connexion.RestyResolver('api'))
app.register_blueprint(api.api, url_prefix='/api')
app.register_blueprint(auth.auth_api, url_prefix='/auth')
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--debug",
dest='debug',
help="run in debug mode",
action="store_true",
default=0)
args = parser.parse_args()
app.app_context().push()
db_utils.init_db(app)
