def register_error_handlers(self):
def prepare_error(message, description, code = None):
if not code:
code = 500
response = jsonify(
code = code,
message = message,
description = description
)
response.status_code = code
return response
@self.errorhandler(HTTPException)
def http_error(ex):
return prepare_error(ex.message, re.sub('<[^<]+?>', '', ex.description), ex.code)
@self.errorhandler(CollectorException)
def application_error(ex):
self.logger.warn("%s: %s [%s]", ex.__class__.__name__, ex.message, ex.description)
return prepare_error(ex.message, ex.description, ex.code)
@self.errorhandler(Exception)
def error(ex):
return prepare_error(ex.message, None)
for code in default_exceptions.iterkeys():
self.error_handler_spec[None][code] = http_error
def run_daemon(environment, log_level, config_file):
create_app(app, log_level, config_file, True)
app.conf.set("enviro", "run", environment)
app.logger.info('Environment: %s' % environment)
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
app.register_blueprint(auth.backend)
app.register_blueprint(messages.backend)
app.logger.info("Loading applications...")
applications.get()
# Load framework blueprints
app.logger.info("Loading frameworks...")
register_frameworks(app)
app.logger.info("Initializing Genesis (if present)...")
app.register_blueprint(genesis.backend)
tracked_services.initialize()
app.logger.info("Server is up and ready")
try:
app.run(host="0.0.0.0", port=8000)
except KeyboardInterrupt:
app.logger.info("Received interrupt")
def create_app():
app = Flask(__name__)
app.config.from_object(bark.config)
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
# Component imports. Must be here to fix cyclical problems
from auth import bp_auth
app.register_blueprint(bp_auth)
from swipes import bp_swipes
app.register_blueprint(bp_swipes, url_prefix='/swipes')
from events import bp_events
app.register_blueprint(bp_events, url_prefix='/events')
from devices import bp_devices
app.register_blueprint(bp_devices, url_prefix='/devices')
from persons import bp_persons
app.register_blueprint(bp_persons, url_prefix='/persons')
from groups import bp_groups
app.register_blueprint(bp_groups, url_prefix='/groups')
@app.route('/')
def hello():
return "Hello World"
db.init_app(app)
return app
def make_json_app(import_name, **kwargs):
"""Creates a JSON-oriented Flask app.
All error responses that you don't specifically manage yourself will have
application/json content type, and will contain JSON that follows the
libnetwork remote driver protocol.
{ "Err": "405: Method Not Allowed" }
See:
- https://github.com/docker/libnetwork/blob/3c8e06bc0580a2a1b2440fe0792fbfcd43a9feca/docs/remote.md#errors # noqa
"""
app = Flask(import_name, **kwargs)
@app.errorhandler(NeutronClientException)
def make_json_error(ex):
response = jsonify({"Err": str(ex)})
response.status_code = (ex.code if isinstance(ex, HTTPException)
else ex.status_code
if isinstance(ex, NeutronClientException)
else 500)
content_type = 'application/vnd.docker.plugins.v1+json; charset=utf-8'
response.headers['Content-Type'] = content_type
return response
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
return app
def make_rest_app(import_name, **kwargs):
"""
Creates a JSON-oriented Flask app.
All error responses that you don't specifically
manage yourself will have application/json content
type, and will contain JSON like this (just an example):
{ "message": "405: Method Not Allowed" }
"""
def make_rest_error(ex):
# app.logger.info("in make rest error")
# app.logger.info(str(ex))
if request_wants_json():
response = jsonify(message=str(ex))
else:
response = Response('<message>{}</message>'.format(str(ex)))
response.status_code = (ex.code
if isinstance(ex, HTTPException)
else 500)
return response
app = Flask(import_name, **kwargs)
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_rest_error
return app
def make_json_app(import_name, **kwargs):
"""
Creates a JSON-oriented Flask app.
All error responses that you don't specifically
manage yourself will have application/json content
type, and will contain JSON like this (just an example):
{ "message": "405: Method Not Allowed" }
"""
def make_json_error(ex):
pprint.pprint(ex)
pprint.pprint(ex.code)
#response = jsonify(message=str(ex))
response = jsonify(ex)
response.status_code = (ex.code
if isinstance(ex, HTTPException)
else 500)
return response
app = Flask(import_name, **kwargs)
#app.debug = True
app.secret_key = id_generator(24)
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
return app
def make_json_app(import_name):
"""
Creates a JSON-oriented Flask app.
All error responses that you don't specifically
manage yourself will have application/json content
type, and will contain JSON like this (just an example):
{ "message": "405: Method Not Allowed" }
"""
def make_json_error(ex):
message = str(ex)
status = ''
code = 500
if isinstance(ex, HTTPException):
code = ex.code
else:
code = 500
if code in [401, 403, 405, 415]:
status = 'fail'
response = jsonify(status=status, data=None)
else:
status = 'error'
response = jsonify(status=status, data=None, message=message)
response.status_code = code
return response
app = Flask(import_name)
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
return app
def make_json_app(import_name, **kwargs):
"""
Creates a JSON-oriented Flask app.
All error responses that you don't specifically
manage yourself will have application/json content
type, and will contain JSON like this (just an example):
{ "message": "405: Method Not Allowed" }
"""
def make_json_error(ex):
response = flask.jsonify(Message=str(ex))
response.status_code = (ex.code
if isinstance(ex, HTTPException)
else 500)
return response
app = flask.Flask(import_name, **kwargs)
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
# Add logging
handler = logging.StreamHandler()
handler.setLevel(logging.INFO)
app.logger.addHandler(handler)
return app
def make_json_app(import_name, **kwargs):
"""
Creates a JSON-oriented Flask app.
All error responses that you don't specifically
manage yourself will have application/json content
type, and will contain JSON like this (just an example):
{ "message": "405: Method Not Allowed" }
http://flask.pocoo.org/snippets/83/
"""
def make_json_error(ex):
response = jsonify(message=str(ex))
response.status_code = (ex.code
if isinstance(ex, HTTPException)
else 500)
return response
app = Flask(import_name, **kwargs)
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
return app
def create_app(environment=None):
'''
Create an app instance
'''
app = Flask('backend')
app.url_map.converters['ObjectId'] = BSONObjectIdConverter
# Config app for environment
if not environment:
environment = os.environ.get('BACKEND_ENVIRONMENT', 'Local')
app.config.from_object('backend.backend.settings.%s' % environment)
# convert exceptions to JSON
def make_json_error(ex):
response = jsonify(message=str(ex))
response.status_code = (ex.code
if isinstance(ex, HTTPException)
else 500)
return response
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
from backend.backend.views.api import api
app.register_module(api)
# initialize modules
admin.init_app(app)
db.init_app(app)
login_manager.setup_app(app)
mail.init_app(app)
return app
def json_flask_app(import_name, **kwargs):
def make_json_error(ex):
response = jsonify(message=str(ex), code=ex.code if isinstance(ex, HTTPException) else 500)
return response
app = Flask(import_name, **kwargs)
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
return app
def install_errorhandler(app):
def errorhandler(error):
if not isinstance(error, exceptions.HTTPException):
error = getattr(exceptions, error.__class__.__name__)()
return error.get_response(request.environ)
for code in default_exceptions.iterkeys():
app.register_error_handler(code, errorhandler)
def setup_json_errors(app):
""" Setup JSON error responses for the given Flask application.
Args:
app (Flask): A Flask application instance.
"""
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = _make_json_error
def setup_json_errors(app):
""" Setup JSON error responses for the given Flask application.
Args:
app (flask.Flask): A Flask application instance.
"""
for code in default_exceptions.iterkeys():
app.register_error_handler(code, _make_json_error)
def __init__(self, name):
Flask.__init__(self, name)
status_view = CephStatusView.as_view('status')
self.add_url_rule('/', view_func=status_view)
# add custom error handler
for code in default_exceptions.iterkeys():
self.error_handler_spec[None][code] = self.make_json_error
def make_json_app():
def make_json_error(ex):
response = jsonify(message=str(ex))
response.status_code = (ex.code
if isinstance(ex, HTTPException) else 500)
return response
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
def create_app(option):
app = Flask(__name__)
config = config_factory.get(option)
app.config.from_object(config)
from common import create_jinja_filters, random_pwd
create_jinja_filters(app)
from webapp.api import api
from webapp.client import client
from webapp.media import media
app.register_blueprint(client)
app.register_blueprint(api, url_prefix=Constants.API_V1_URL_PREFIX)
app.register_blueprint(media, url_prefix=Constants.MEDIA_URL_PREFIX)
csrf.init_app(app)
compress.init_app(app)
gravatar.init_app(app)
db.init_app(app)
migrate.init_app(app, db)
admin.init_app(app)
mail.init_app(app)
from models import User, Role
from webapp.forms import ExtendedRegisterForm
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security.init_app(app, user_datastore, register_form=ExtendedRegisterForm)
with app.app_context():
api_manager.init_app(app, flask_sqlalchemy_db=db)
@app.before_request
def before_request():
g.constants = Constants
g.config = app.config
g.mode = app.config.get('MODE')
@app.after_request
def redirect_if_next(response_class):
payload = request.args if request.method == 'GET' else request.form
if 'api_next' in payload:
if not response_class.status_code == 200:
flash(response_class.data)
return redirect(request.referrer)
return redirect(payload.get('api_next'))
return response_class
patch_request_class(app, Constants.MAX_FILE_SIZE)
from webapp.common import make_json_error
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
configure_uploads(app, (user_images, ))
return app
def configure_flask_exception_handler(app):
"""
Set the exception handler for the default flask exceptions
to return the expected json response.
:param app:The flask app instance
:return:
"""
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
def make_json_app():
def make_json_error(ex):
response = jsonify(message=str(ex))
response.status_code = (ex.code
if isinstance(ex, HTTPException)
else 500)
return response
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
def __init__(self, name):
Flask.__init__(self, name)
dhc_view = StateView.as_view('status')
self.add_url_rule('/', defaults={'env': None}, view_func=dhc_view)
self.add_url_rule('/<env>', view_func=dhc_view)
# add custom error handler
for code in default_exceptions.iterkeys():
self.register_error_handler(code, self.make_json_error)
def __init__(self, name):
Flask.__init__(self, name)
dhc_view = StateView.as_view('status')
self.add_url_rule('/', defaults={'env': None}, view_func=dhc_view)
self.add_url_rule('/<env>', view_func=dhc_view)
# add custom error handler
for code in default_exceptions.iterkeys():
self.register_error_handler(code, self.make_json_error)
def create_app(settings="realize.settings"):
app = Flask(__name__, template_folder='templates')
app.config.from_object(settings)
db.app = app
db.init_app(app)
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
return app
def create_app(settings="realize.settings"):
app = Flask(__name__, template_folder='templates')
app.config.from_object(settings)
db.app = app
db.init_app(app)
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
return app
def __init__(self, name):
template_folder = os.path.join(os.path.dirname(__file__), 'templates')
Flask.__init__(self, name, template_folder=template_folder)
status_view = CephStatusView.as_view('status')
self.add_url_rule('/', view_func=status_view)
# add custom error handler
for code in default_exceptions.iterkeys():
self.error_handler_spec[None][code] = self.make_json_error
def setup_json_handlers(app):
def make_json_error(ex):
code = ex.code if isinstance(ex, HTTPException) else 500
response = jsonify(message=str(ex), error=code)
response.status_code = code
return response
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
return app
def __init__(self, name):
template_folder = os.path.join(os.path.dirname(__file__), 'templates')
static_folder = os.path.join(os.path.dirname(__file__), 'static')
Flask.__init__(self, name, template_folder=template_folder, static_folder=static_folder)
status_view = CephStatusView.as_view('status')
self.add_url_rule('/', view_func=status_view)
# add custom error handler
for code in default_exceptions.iterkeys():
self.error_handler_spec[None][code] = self.make_json_error
def create_json_app(config):
app = Flask(__name__)
CORS(app)
app.config.from_object(config)
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
db.init_app(app)
with app.app_context():
db.create_all()
app.app_context().push()
return app
def init_error_responses(app):
"""Make error responses use JSON."""
from werkzeug.exceptions import default_exceptions
from werkzeug.exceptions import HTTPException
make_json_error = lambda ex: json_response(dict(description=str(ex)), ex.code)
for code in default_exceptions.iterkeys():
if code != 500: app.errorhandler(code)(make_json_error)
# Use HTTP Basic auth (json object in password field)
app.errorhandler(401)(lambda ex: json_response(
dict(description='Authenticate with HTTP Basic json:{auth object}'), 401,
#headers={'WWW-Authenticate': 'Basic realm="JSON auth required"'}
))
def use_pretty_default_error_handlers(app):
"""Set default error handlers to use lib.make_error.
With thanks to http://flask.pocoo.org/snippets/15/
"""
def make_json_error(ex):
status_code = ex.code if isinstance(ex, HTTPException) else 500
return make_error('', status_code)
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
def init_errorhandlers(app):
""" Set default error pages (404, 505, etc.). """
def make_json_error(error):
response = jsonify(message=str(error))
response.status_code = (error.code
if isinstance(error, HTTPException)
else 500)
return response
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
def jsonApp(app):
"""Converts all flask errors to JSON"""
def make_json_error(error):
response = jsonify(data={}, errors=[{'message': str(error)}])
response.status_code = (error.code
if isinstance(error, HTTPException) else 500)
return response
for code in default_exceptions.iterkeys():
if code != 500 and code != 405 and code != 400:
app.register_error_handler(code, make_json_error)
return app
def use_pretty_default_error_handlers(app):
"""Set default error handlers to use lib.make_error.
With thanks to http://flask.pocoo.org/snippets/15/
"""
def make_json_error(ex):
status_code = ex.code if isinstance(ex, HTTPException) else 500
return make_error('', status_code)
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
def create_app(config):
app = Flask(__name__)
app.template_folder = join(dirname(__file__), 'templates')
app.static_folder = join(dirname(__file__), 'static')
for code in default_exceptions.iterkeys():
app.register_error_handler(code, make_json_error)
app.config['USER_CONFIG'] = Config(config)
app.register_blueprint(X509ResourceV1.as_blueprint(), url_prefix='/v1/x509')
app.register_blueprint(KeyResourceV1.as_blueprint(), url_prefix='/v1/key')
return app
def create_app():
app = Flask(__name__)
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
app.config['SQLALCHEMY_DATABASE_URI'] = settings.SQLALCHEMY_DATABASE_URI
app.secret_key = settings.SESSION_SECRET_KEY
db.app = app
db.init_app(app)
return app
def configure_error_handlers(app):
"""Generic error-handling logic."""
# Following snippet adapted from: http://flask.pocoo.org/snippets/83/
def make_json_error(exc):
message = exc.description
error(message)
response = jsonify(message=message)
response.status_code = (exc.code
if isinstance(exc, HTTPException) else 500)
return response
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
def configure_error_handlers(app):
"""Generic error-handling logic."""
# Following snippet adapted from: http://flask.pocoo.org/snippets/83/
def make_json_error(exc):
message = exc.description
error(message)
response = jsonify(message=message)
response.status_code = (exc.code
if isinstance(exc, HTTPException)
else 500)
return response
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
def build_json_app(name, **kwargs):
"""
Creates a json api flask app. From http://flask.pocoo.org/snippets/83/
"""
def make_json_error(ex):
response = jsonify(message = str(ex))
response.status_code = (ex.code if isinstance(ex, HTTPException) else 500)
return response
app = Flask(name, **kwargs)
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
return app
def init_error_responses(app):
"""Make error responses use JSON."""
from werkzeug.exceptions import default_exceptions
from werkzeug.exceptions import HTTPException
make_json_error = lambda ex: json_response(dict(description=str(ex)), ex.
code)
for code in default_exceptions.iterkeys():
if code != 500: app.errorhandler(code)(make_json_error)
# Use HTTP Basic auth (json object in password field)
app.errorhandler(401)(
lambda ex: json_response(
dict(description='Authenticate with HTTP Basic json:{auth object}'
),
401,
#headers={'WWW-Authenticate': 'Basic realm="JSON auth required"'}
))
def Blueprint(name, **kwargs):
from flask import Blueprint
from werkzeug.exceptions import default_exceptions
from cloudapp.authentication.decorators import load_user
error_if_exists = kwargs.pop('subdomain', None)
if error_if_exists:
raise RuntimeError("[cloudapp_api] Blueprint: subdomain is not an allowed keyword")
bp = Blueprint(name, __name__, subdomain="api", **kwargs)
bp.before_request(load_user)
bp.before_request(_process_request_json)
for code in default_exceptions.iterkeys():
if code >= 500: continue
@bp.errorhandler(code)
def errorhandler(code):
return _json_errorhandler(code)
return bp
def record_auth(setup_state):
# Runs when the Blueprint binds to the main application
app = setup_state.app
def default_json_error(ex):
""" Exception -> flask JSON responder """
app.logger.error(
"Uncaught error thrown by Flask/Werkzeug: {0}".format(ex))
response = flask_jsonify(message=str(ex), type='api_error')
response.status_code = (ex.code
if isinstance(ex, HTTPException) else 500)
return response
# Patch all error handlers in werkzeug
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = default_json_error
def make_app():
"""App builder (wsgi)
Entry point for Savanna REST API server
"""
app = Flask('savanna.api')
@app.route('/', methods=['GET'])
def version_list():
return render({
"versions": [
{"id": "v0.2", "status": "CURRENT"}
]
})
app.register_blueprint(api_v02.rest, url_prefix='/v0.2')
setup_storage(app)
setup_scheduler(app)
def make_json_error(ex):
status_code = (ex.code
if isinstance(ex, HTTPException)
else 500)
description = (ex.description
if isinstance(ex, HTTPException)
else str(ex))
return render({'error': status_code, 'error_message': description},
status=status_code)
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
app.wsgi_app = auth_valid(app.config)(app.wsgi_app)
app.wsgi_app = auth_token(
app.config,
auth_host=CONF.os_auth_host,
auth_port=CONF.os_auth_port,
auth_protocol=CONF.os_auth_protocol,
admin_user=CONF.os_admin_username,
admin_password=CONF.os_admin_password,
admin_tenant=CONF.os_admin_tenant_name
)(app.wsgi_app)
return app
def configure_app(app):
"""Retrieve App Configuration."""
app.config.from_object('sql_json_bridge.default_config')
try:
app.config.from_envvar('SQL_JSON_BRIDGE_CONFIG')
except:
pass
app.config["DATABASES"] = load_database_configs(
app.config["DATABASE_CONFIG_LOCATION"])
if app.config["LEGACY_SUPPORT"]:
from sql_json_bridge.legacy.views import legacy
DEFAULT_BLUEPRINTS.append(legacy)
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
def record_auth(setup_state):
# Runs when the Blueprint binds to the main application
app = setup_state.app
def default_json_error(ex):
""" Exception -> flask JSON responder """
app.logger.error("Uncaught error thrown by Flask/Werkzeug: {0}"
.format(ex))
response = flask_jsonify(message=str(ex), type='api_error')
response.status_code = (ex.code
if isinstance(ex, HTTPException)
else 500)
return response
# Patch all error handlers in werkzeug
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = default_json_error
def make_json_app(import_name, **kwargs):
"""
{ "message": "405: Method Not Allowed" }
"""
def make_json_error(ex):
response = jsonify(message=str(ex))
response.status_code = (ex.code
if isinstance(ex, HTTPException) else 500)
return response
app = Flask(import_name, **kwargs)
for code in default_exceptions.iterkeys():
app.errorhandler(HTTPException)(make_json_error)
# app.error_handler_spec[None][code] = make_json_error
return app
def register_error_handlers(self):
from werkzeug.exceptions import default_exceptions
from werkzeug.exceptions import HTTPException
# http://flask.pocoo.org/snippets/83/
def make_json_error(ex):
if hasattr(ex, 'to_json'):
response = jsonify(ex.to_json())
else:
response = jsonify(message=str(ex))
if hasattr(ex, 'status_code'):
response.status_code = ex.status_code
else:
response.status_code = (ex.code
if isinstance(ex, HTTPException)
else 500)
return response
for code in default_exceptions.iterkeys():
self.app.error_handler_spec[None][code] = make_json_error
def install_errorhandler(app):
def errorhandler(err):
accept = request.headers.get('Accept', '')
if 'application/json' in accept:
data = {
'status': err.code,
'name': err.name,
'description': err.description
}
res = json.dumps(data)
return Response(res, mimetype='application/json', status=err.code)
html = "<h1>{0}: {1}</h1><p>{2}</p>".format(err.code, err.name,
err.description)
return Response(html, status=err.code)
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = errorhandler
def make_json_app(import_name, **kwargs):
"""
handle exceptions as json outputs
"""
from werkzeug.exceptions import default_exceptions
from werkzeug.exceptions import HTTPException
def make_json_error(ex):
response = jsonify(message=str(ex))
response.status_code = (ex.code
if isinstance(ex, HTTPException) else 500)
return response
app = Flask(import_name, **kwargs)
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
return app
def JSONApp(import_name, **kwargs):
def make_json_error(ex):
response = jsonify(message=str(ex))
response.status_code = (ex.code
if isinstance(ex, HTTPException) else 500)
h = response.headers
h['Access-Control-Allow-Origin'] = '*'
h['Access-Control-Max-Age'] = str(21600)
h['Access-Control-Allow-Headers'] = 'CONTENT-TYPE'
return response
app = Flask(import_name, **kwargs)
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
return app
def get_admin_app(name):
#FIXME : this actually gets ALL config values, not just db values
db_config = td_config.get_db_config()
#secret_config,public_config = td_config.get_configs()
db_info = DbInfo(db_config)
db_url = db_util.generate_db_url(name, db_info)
if not database_exists(db_url):
return None
app = get_generic_app(name)
db_handle = db_util.create_db_handle(db_url, app)
app.tables = ImportedTables(db_handle)
app.register_blueprint(admin_login_blueprint)
app.register_blueprint(admin_manage_blueprint)
LoginManager().init_app(app)
auth.generate_user_loader(app)
auth.generate_identity_loaded(app)
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
return app
def make_json_app(import_name, **kwargs):
"""
Creates a JSON-oriented Flask app.
All error responses that you don't specifically
manage yourself will have application/json content
type, and will contain JSON like this (just an example):
{ "message": "405: Method Not Allowed" }
"""
def make_json_error(ex):
response = jsonify(message=str(ex))
response.status_code = (ex.code
if isinstance(ex, HTTPException) else 500)
return response
app = Flask(import_name, **kwargs)
for code in default_exceptions.iterkeys():
app.register_error_handler(code, make_json_error)
return app
def make_json_app(app, **kwargs):
"""
Creates a JSON-oriented Flask app.
All error responses that you don't specifically
manage yourself will have application/json content
type, and will contain JSON like this (just an example):
{ "message": "405: Method Not Allowed" }
"""
def make_json_error(ex):
status_code = ex.code if isinstance(ex, HTTPException) else 500
response = jsonify(message=str(ex), status_code=status_code)
response.status_code = status_code
return response
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
return app
def __configure(self):
for code in default_exceptions.iterkeys():
self.error_handler_spec[None][code] = RemoteDslrApiError.handle
config = Settings().get_config
self.address = config["server"]["address"]
self.port = int(config["server"]["port"])
self.debug = config["server"]["port"] in ['True', 'true']
use_ssl = config["server"]["ssl"] in ['True', 'true']
auto_announce = config["general"]["auto_announce"] in ['True', 'true']
if auto_announce:
AutoAnnounce(self.port, use_ssl)
self.options = {'use_reloader': False, 'threaded': True}
if use_ssl:
abs_path = path.dirname(path.abspath(__file__)) + "/../"
cert_file = abs_path + config["server"]["ssl_crt"]
key_file = abs_path + config["server"]["ssl_key"]
ssl_context = (cert_file, key_file)
self.options['ssl_context'] = ssl_context
def make_json_app(import_name, **kwargs):
"""
handle exceptions as json outputs
"""
from werkzeug.exceptions import default_exceptions
from werkzeug.exceptions import HTTPException
def make_json_error(ex):
response = jsonify(message=str(ex))
response.headers[
'Access-Control-Allow-Headers'] = 'Origin, X-Requested-With, Content-Type, Accept, Authorization'
response.headers['Access-Control-Allow-Origin'] = '*'
response.status_code = (ex.code
if isinstance(ex, HTTPException) else 500)
return response
app = Flask(import_name, **kwargs)
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
return app
def make_json_app(app):
"""
Creates a JSON-oriented Flask app.
All error responses that you don't specifically
manage yourself will have application/json content
type, and will contain JSON like this (just an example):
{ "message": "405: Method Not Allowed" }
"""
def make_json_error(ex):
response = jsonify(message=str(ex),
traceback='not available with DEBUG off'
if not app.debug else traceback.format_exc())
response.status_code = (ex.code
if isinstance(ex, HTTPException) else 500)
return response
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
return app
def make_json_app(import_name, **kwargs):
'''
Creates a JSON-oriented Flask app.
All error responses that you don't specifically
manage yourself will have application/json content
type, and will contain JSON like this (just an example):
{ 'message': '500: Internal Server Error' }
'''
def make_json_error(ex):
response = jsonify(message=str(ex))
response.status_code = (ex.code
if isinstance(ex, HTTPException) else 500)
return response
app = Flask(import_name, **kwargs)
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
return app
def setup_default_handlers(app):
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
def _register_error_handler(self):
for code in default_exceptions.iterkeys():
self.error_handler_spec[None][code] = self._error_handler
def setup_default_handlers(app):
for code in default_exceptions.iterkeys():
app.register_error_handler(code, make_json_error)
# Handle both /endpoint and /endpoint/ without redirecting.
# Note that we need to set this *before* registering the blueprint.
app.url_map.strict_slashes = False
def default_json_error(ex):
""" Exception -> flask JSON responder """
logger = get_logger()
logger.error('Uncaught error thrown by Flask/Werkzeug', exc_info=ex)
response = jsonify(message=str(ex), type='api_error')
response.status_code = (ex.code if isinstance(ex, HTTPException) else 500)
return response
# Patch all error handlers in werkzeug
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = default_json_error
@app.before_request
def auth():
""" Check for account ID on all non-root URLS """
if request.path in ('/accounts', '/accounts/', '/', '/n', '/n/') \
or request.path.startswith('/w/'):
return
if request.path.startswith('/n/'):
ns_parts = filter(None, request.path.split('/'))
namespace_public_id = ns_parts[1]
valid_public_id(namespace_public_id)