def database(app, request):
"""Session-wide test database."""
def teardown():
if db.engine.dialect.name == 'sqlite':
# since sqlite was created in a temp file we skip the drops.
return
try:
db.engine.execute('DROP TABLE vulnerability CASCADE')
except Exception:
pass
try:
db.engine.execute('DROP TABLE vulnerability_template CASCADE')
except Exception:
pass
db.drop_all()
# Disable check_vulnerability_host_service_source_code constraint because
# it doesn't work in sqlite
vuln_constraints = db.metadata.tables['vulnerability'].constraints
try:
vuln_constraints.remove(
next(constraint for constraint in vuln_constraints
if constraint.name ==
'check_vulnerability_host_service_source_code'))
except StopIteration:
pass
db.init_app(app)
db.create_all()
request.addfinalizer(teardown)
return db
def create_app(config_mode):
app = Flask(__name__, static_url_path='', static_folder='build')
app.config.from_object(config_by_mode[config_mode])
cors = CORS(app)
db.init_app(app)
init_db(app)
login_manager.init_app(app)
app.register_blueprint(auth_bp, url_prefix='/api/auth')
app.register_blueprint(home_bp, url_prefix='/api/home')
app.register_blueprint(new_project_bp, url_prefix='/api/new_project')
app.register_blueprint(project_change_status_bp,
url_prefix='/api/project_change_status')
if config_mode == 'prod':
@app.route('/')
def index():
return app.send_static_file('index.html')
@app.errorhandler(404)
def not_found(e):
return app.send_static_file('index.html')
return app
def create_app() -> Flask:
"""Creates and returns the Flask WSGI application
and initializes helping components"""
# Initialize json support for wtforms
wtforms_json.init()
# Define the WSGI Application object
app = Flask(__name__,
template_folder="../../",
static_folder="../../static")
# Configurations
app.config.from_object('server.config')
# Initialize database with application
db.init_app(app)
with app.test_request_context():
db.create_all()
# Initialize login manager with application
login_manager.init_app(app)
# Setup the routes
define_routes(app)
return app
def _init_database(app):
db_path = os.path.join(app.instance_path, "server.sqlite")
app.config.from_mapping(SECRET_KEY='SECRET_KEY',
SQLALCHEMY_DATABASE_URI='sqlite:///' + db_path,
SQLALCHEMY_TRACK_MODIFICATIONS=False)
with app.app_context():
db.init_app(app)
db.create_all()
def create_app(test_config=None):
app = Flask(__name__)
CORS(app) # add CORS
# check environment variables to see which config to load
env = os.environ.get("FLASK_ENV", "dev")
if test_config:
# ignore environment variable config if config was given
app.config.from_mapping(**test_config)
else:
app.config.from_object(config[env])
# logging
formatter = Log_Formatter(
"%(asctime)s %(remote_addr)s: requested %(url)s: %(levelname)s in [%(module)s: %(lineno)d]: %(message)s"
)
# Set stream logger
stream = logging.StreamHandler()
stream.setLevel(logging.DEBUG)
stream.setFormatter(formatter)
app.logger.addHandler(stream)
app.logger.setLevel(logging.DEBUG)
# Set Logging to file
if app.config.get("LOG_FILE"):
file_handler = logging.FileHandler(app.config.get("LOG_FILE"))
file_handler.setLevel(logging.DEBUG)
file_handler.setFormatter(formatter)
app.logger.addHandler(file_handler)
# if not prod recreate db every-run
if env != "prod":
db_url = app.config["SQLALCHEMY_DATABASE_URI"]
if not database_exists(db_url):
create_database(db_url)
# register sqlalchemy to this app
db.init_app(app)
Migrate(app, db)
# Register blueprints
app.register_blueprint(main)
app.register_blueprint(key)
app.register_blueprint(user)
# register error Handler
app.register_error_handler(Exception, all_exception_handler)
return app
def create_app():
app = Flask(__name__)
app.config.from_object('server.config.DevelopmentConfig')
app.config['BUNDLE_ERRORS'] = True
app.url_map.strict_slashes = False
cors = CORS(app, resources={r"/api/*": {"origins": "*"}})
register_flask_blueprints(app)
from server.models import db
db.init_app(app)
return app
def setup_app(app):
# Create tables if they do not exist already
@app.before_first_request
def create_tables():
db.create_all()
db.init_app(app)
setup_oauth(app)
app.register_blueprint(home, url_prefix='')
app.register_blueprint(courses, url_prefix='')
app.register_blueprint(exercises, url_prefix='')
app.register_blueprint(hooks, url_prefix='')
app.register_blueprint(embed, url_prefix='')
def initApiServer(conf):
# load config
app.config.from_object(conf)
# init flask sqlalchemy
db.app = app
db.init_app(app)
db.create_all()
# init API endpoints
manager = APIManager(app, flask_sqlalchemy_db=db)
createApi(manager)
return app
def create_app(config_name):
from server.models import db
app = Flask(__name__)
rq.init_app(app)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
db.init_app(app)
login_manager.init_app(app)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
return app
def create_app():
"""flask application generator
:return: flask application
"""
app = Flask(__name__)
config.init_app(app)
db.init_app(app)
Swagger(app)
with app.app_context():
""" application blueprints """
from server.api_1_0.views import api as api_blueprint
app.register_blueprint(api_blueprint, url_prefix='/api/v1')
return app
def database(app, request):
"""Session-wide test database."""
# Disable check_vulnerability_host_service_source_code constraint because
# it doesn't work in sqlite
vuln_constraints = db.metadata.tables['vulnerability'].constraints
try:
vuln_constraints.remove(
next(constraint for constraint in vuln_constraints
if constraint.name ==
'check_vulnerability_host_service_source_code'))
except StopIteration:
pass
db.init_app(app)
db.create_all()
return db
def create_app():
app = Flask(__name__)
app.config.from_object(AppConfig())
db.init_app(app)
with app.app_context():
for blueprint in blueprints:
app.register_blueprint(blueprint)
app.register_error_handler(KeyError, handle_key_error)
app.register_error_handler(IntegrityError, handle_integrity_error)
app.register_error_handler(ValueError, handle_value_error)
app.register_error_handler(
StatementError,
handle_value_error) # StatementError is a subclass of ValueError
app.register_error_handler(NotFound, handle_not_found)
app.register_error_handler(BadRequest, handle_bad_request)
return app
def create_app():
app = Flask(__name__)
app.config.from_pyfile('config.py')
# db
db.init_app(app)
migrate.init_app(app, db)
marshmallow.init_app(app)
# CORS
cors = CORS(app, resources={r"/api/*": {"origins": "*"}})
cors.init_app(app)
# blueprint apps
app.register_blueprint(books_blueprint, url_prefix='/api/books')
# static files for dev
return app
def create_app(instance_path=None, static_folder='../frontend/build'):
"""Create and configure an instance of the Flask application."""
app = Flask(__name__,
instance_path=instance_path,
static_url_path='/',
static_folder=static_folder,
instance_relative_config=True)
try:
os.makedirs(app.instance_path)
except OSError:
pass
db_path = os.path.join(app.instance_path, "server.sqlite")
app.config.from_mapping(SECRET_KEY='SECRET_KEY',
SQLALCHEMY_DATABASE_URI='sqlite:///' + db_path,
SQLALCHEMY_TRACK_MODIFICATIONS=False)
db.init_app(app)
# apply the blueprints to the app
from server import auth, api
app.register_blueprint(auth.bp)
app.register_blueprint(api.bp)
@app.errorhandler(ValueError)
def http_error_handler(error):
return jsonify(code=400, message=str(error)), 400
@app.errorhandler(HTTPException)
def http_error_handler(error):
return jsonify(code=error.code, message=error.description), error.code
@app.route('/')
def home():
return redirect('/index.html', code=302)
with app.app_context():
db.create_all()
return app
def create_app(object_name, env="prod"):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. server.settings.ProdConfig
env: The name of the current environment, e.g. prod or dev
"""
app = Flask(__name__)
app.config.from_object(object_name)
app.config['ENV'] = env
cors = CORS(app)
# initialize the cache
cache.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
login_manager.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
app.register_blueprint(main)
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
from server.main import main
app.register_blueprint(main)
from server.api import api
app.register_blueprint(api, url_prefix="/api")
from server.replays import replays
app.register_blueprint(replays, url_prefix="/replays")
from server.server import server
app.register_blueprint(server, url_prefix="/servers")
from server.maps import maps
app.register_blueprint(maps, url_prefix="/maps")
db.init_app(app)
return app
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. server.settings.ProdConfig
env: The name of the current environment, e.g. prod or dev
"""
app = Flask(__name__)
app.config.from_object(object_name)
# initialize the cache
cache.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
login_manager.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
app.register_blueprint(main)
return app
def create_app(db_connection_string=None, testing=None):
app = Flask(__name__)
try:
app.config['SECRET_KEY'] = server.config.faraday_server.secret_key
except Exception:
save_new_secret_key(app)
login_failed_message = ("Invalid username or password", 'error')
app.config.update({
'SECURITY_PASSWORD_SINGLE_HASH':
True,
'WTF_CSRF_ENABLED':
False,
'SECURITY_USER_IDENTITY_ATTRIBUTES': ['username'],
'SECURITY_POST_LOGIN_VIEW':
'/_api/session',
'SECURITY_POST_LOGOUT_VIEW':
'/_api/login',
'SECURITY_POST_CHANGE_VIEW':
'/_api/change',
'SECURITY_CHANGEABLE':
True,
'SECURITY_SEND_PASSWORD_CHANGE_EMAIL':
False,
'SECURITY_MSG_USER_DOES_NOT_EXIST':
login_failed_message,
# The line bellow should not be necessary because of the
# CustomLoginForm, but i'll include it anyway.
'SECURITY_MSG_INVALID_PASSWORD':
login_failed_message,
'SESSION_TYPE':
'filesystem',
'SESSION_FILE_DIR':
server.config.FARADAY_SERVER_SESSIONS_DIR,
'SQLALCHEMY_TRACK_MODIFICATIONS':
False,
'SQLALCHEMY_RECORD_QUERIES':
True,
# app.config['SQLALCHEMY_ECHO'] = True
'SECURITY_PASSWORD_SCHEMES': [
'bcrypt', # This should be the default value
# 'des_crypt',
'pbkdf2_sha1', # Used by CouchDB passwords
# 'pbkdf2_sha256',
# 'pbkdf2_sha512',
# 'sha256_crypt',
# 'sha512_crypt',
'plaintext', # TODO: remove it
],
'PERMANENT_SESSION_LIFETIME':
datetime.timedelta(hours=12),
})
try:
storage_path = server.config.storage.path
except AttributeError:
logger.warn(
'No storage section or path in the .faraday/server.ini. Setting the default value to .faraday/storage'
)
storage_path = setup_storage_path()
if not DepotManager.get('default'):
if testing:
DepotManager.configure('default', {'depot.storage_path': '/tmp'})
else:
DepotManager.configure('default',
{'depot.storage_path': storage_path})
check_testing_configuration(testing, app)
try:
app.config[
'SQLALCHEMY_DATABASE_URI'] = db_connection_string or server.config.database.connection_string.strip(
"'")
except AttributeError:
logger.info(
'Missing [database] section on server.ini. Please configure the database before running the server.'
)
except NoOptionError:
logger.info(
'Missing connection_string on [database] section on server.ini. Please configure the database before running the server.'
)
from server.models import db
db.init_app(app)
#Session(app)
# Setup Flask-Security
app.user_datastore = SQLAlchemyUserDatastore(
db, user_model=server.models.User,
role_model=None) # We won't use flask security roles feature
Security(app, app.user_datastore, login_form=CustomLoginForm)
# Make API endpoints require a login user by default. Based on
# https://stackoverflow.com/questions/13428708/best-way-to-make-flask-logins-login-required-the-default
app.view_functions['security.login'].is_public = True
app.view_functions['security.logout'].is_public = True
app.debug = server.config.is_debug_mode()
minify_json_output(app)
for handler in LOGGING_HANDLERS:
app.logger.addHandler(handler)
register_blueprints(app)
register_handlers(app)
return app
def create_app(db_connection_string=None, testing=None):
app = Flask(__name__)
try:
secret_key = server.config.faraday_server.secret_key
except Exception:
# Now when the config file does not exist it doesn't enter in this
# condition, but it could happen in the future. TODO check
save_new_secret_key(app)
else:
if secret_key is None:
# This is what happens now when the config file doesn't exist.
# TODO check
save_new_secret_key(app)
else:
app.config['SECRET_KEY'] = secret_key
login_failed_message = ("Invalid username or password", 'error')
app.config.update({
'SECURITY_PASSWORD_SINGLE_HASH': True,
'WTF_CSRF_ENABLED': False,
'SECURITY_USER_IDENTITY_ATTRIBUTES': ['username'],
'SECURITY_POST_LOGIN_VIEW': '/_api/session',
'SECURITY_POST_LOGOUT_VIEW': '/_api/login',
'SECURITY_POST_CHANGE_VIEW': '/_api/change',
'SECURITY_CHANGEABLE': True,
'SECURITY_SEND_PASSWORD_CHANGE_EMAIL': False,
'SECURITY_MSG_USER_DOES_NOT_EXIST': login_failed_message,
# The line bellow should not be necessary because of the
# CustomLoginForm, but i'll include it anyway.
'SECURITY_MSG_INVALID_PASSWORD': login_failed_message,
'SESSION_TYPE': 'filesystem',
'SESSION_FILE_DIR': server.config.FARADAY_SERVER_SESSIONS_DIR,
'SQLALCHEMY_TRACK_MODIFICATIONS': False,
'SQLALCHEMY_RECORD_QUERIES': True,
# app.config['SQLALCHEMY_ECHO'] = True
'SECURITY_PASSWORD_SCHEMES': [
'bcrypt', # This should be the default value
# 'des_crypt',
'pbkdf2_sha1', # Used by CouchDB passwords
# 'pbkdf2_sha256',
# 'pbkdf2_sha512',
# 'sha256_crypt',
# 'sha512_crypt',
'plaintext', # TODO: remove it
],
'PERMANENT_SESSION_LIFETIME': datetime.timedelta(hours=12),
})
storage_path = server.config.storage.path
if not storage_path:
logger.warn('No storage section or path in the .faraday/server.ini. Setting the default value to .faraday/storage')
storage_path = setup_storage_path()
if not DepotManager.get('default'):
if testing:
DepotManager.configure('default', {
'depot.storage_path': '/tmp'
})
else:
DepotManager.configure('default', {
'depot.storage_path': storage_path
})
check_testing_configuration(testing, app)
try:
app.config['SQLALCHEMY_DATABASE_URI'] = db_connection_string or server.config.database.connection_string.strip("'")
except AttributeError:
logger.info('Missing [database] section on server.ini. Please configure the database before running the server.')
except NoOptionError:
logger.info('Missing connection_string on [database] section on server.ini. Please configure the database before running the server.')
from server.models import db
db.init_app(app)
#Session(app)
# Setup Flask-Security
app.user_datastore = SQLAlchemyUserDatastore(
db,
user_model=server.models.User,
role_model=None) # We won't use flask security roles feature
Security(app, app.user_datastore, login_form=CustomLoginForm)
# Make API endpoints require a login user by default. Based on
# https://stackoverflow.com/questions/13428708/best-way-to-make-flask-logins-login-required-the-default
app.view_functions['security.login'].is_public = True
app.view_functions['security.logout'].is_public = True
app.debug = server.config.is_debug_mode()
minify_json_output(app)
for handler in LOGGING_HANDLERS:
app.logger.addHandler(handler)
register_blueprints(app)
register_handlers(app)
return app
def create_app(default_config_path=None):
"""Create and return a Flask application. Reads a config file path from the
OK_SERVER_CONFIG environment variable. If it is not set, reads from
default_config_path instead. This is so we can default to a development
environment locally, but the app will fail in production if there is no
config file rather than dangerously defaulting to a development environment.
"""
app = Flask(__name__)
config_path = os.getenv('OK_SERVER_CONFIG', default_config_path)
if config_path is None:
raise ValueError('No configuration file found'
'Check that the OK_SERVER_CONFIG environment variable is set.')
app.config.from_pyfile(config_path)
# Set REMOTE_ADDR for proxies
num_proxies = app.config.get('NUM_PROXIES', 0)
if num_proxies:
app.wsgi_app = ProxyFix(app.wsgi_app, num_proxies=num_proxies)
# Sentry Error Reporting
sentry_dsn = os.getenv('SENTRY_DSN')
if not app.debug and sentry_dsn:
sentry.init_app(app, dsn=sentry_dsn)
@app.errorhandler(500)
def internal_server_error(error):
return render_template('errors/500.html',
event_id=g.sentry_event_id,
public_dsn=sentry.client.get_public_dsn('https')
), 500
@app.errorhandler(404)
def not_found_error(error):
if request.path.startswith("/api"):
return api.handle_error(error)
return render_template('errors/404.html'), 404
@app.route("/healthz")
def health_check():
return 'OK'
# initialize the cache
cache.init_app(app)
# initialize redis task queues
RQ(app)
# Protect All Routes from csrf
csrf.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
# Flask-Login manager
login_manager.init_app(app)
# Set up logging
logging.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# custom URL handling
converters.init_app(app)
# custom Jinja rendering
app.jinja_env.globals.update({
'utils': utils,
'debug': app.debug,
'instantclick': app.config.get('INSTANTCLICK', True),
'CSRFForm': CSRFForm
})
app.jinja_env.filters.update({
'markdown': utils.convert_markdown,
'pluralize': utils.pluralize,
})
# register our blueprints
# OAuth should not need CSRF protection
csrf.exempt(auth)
app.register_blueprint(auth)
csrf.exempt(oauth)
app.register_blueprint(oauth)
app.register_blueprint(student)
app.register_blueprint(admin, url_prefix='/admin')
app.register_blueprint(about, url_prefix='/about')
# Redis Queue dashboard
csrf.exempt(queue)
app.register_blueprint(queue, url_prefix='/rq')
# API does not need CSRF protection
csrf.exempt(api_endpoints)
app.register_blueprint(api_endpoints, url_prefix=API_PREFIX)
return app
def create_app(default_config_path=None):
"""Create and return a Flask application. Reads a config file path from the
OK_SERVER_CONFIG environment variable. If it is not set, reads from
default_config_path instead. This is so we can default to a development
environment locally, but the app will fail in production if there is no
config file rather than dangerously defaulting to a development environment.
"""
app = Flask(__name__)
config_path = os.getenv('OK_SERVER_CONFIG', default_config_path)
if config_path is None:
raise ValueError(
'No configuration file found'
'Check that the OK_SERVER_CONFIG environment variable is set.')
app.config.from_pyfile(config_path)
# Senty Error Reporting & Other Prod Changes
sentry_dsn = os.getenv('SENTRY_DSN')
if not app.debug:
app.wsgi_app = ProxyFix(app.wsgi_app)
if sentry_dsn:
sentry.init_app(app, dsn=sentry_dsn)
@app.errorhandler(500)
def internal_server_error(error):
return render_template(
'errors/500.html',
event_id=g.sentry_event_id,
public_dsn=sentry.client.get_public_dsn('https')), 500
# In production mode, add log handler to sys.stderr.
app.logger.addHandler(logging.StreamHandler())
app.logger.setLevel(logging.INFO)
@app.errorhandler(404)
def not_found_error(error):
if request.path.startswith("/api"):
return api.handle_error(error)
return render_template('errors/404.html'), 404
# initialize the cache
cache.init_app(app)
# initialize redis task queues
RQ(app)
# Protect All Routes from csrf
csrf.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
# Flask-Login manager
login_manager.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# custom URL handling
converters.init_app(app)
# custom Jinja rendering
app.jinja_env.globals.update({
'utils':
utils,
'debug':
app.debug,
'instantclick':
app.config.get('INSTANTCLICK', True),
'CSRFForm':
CSRFForm
})
app.jinja_env.filters.update({
'markdown': utils.convert_markdown,
'pluralize': utils.pluralize,
})
# register our blueprints
# OAuth should not need CSRF protection
csrf.exempt(auth)
app.register_blueprint(auth)
csrf.exempt(oauth)
app.register_blueprint(oauth)
app.register_blueprint(student)
app.register_blueprint(admin, url_prefix='/admin')
app.register_blueprint(about, url_prefix='/about')
# Redis Queue dashboard
csrf.exempt(queue)
app.register_blueprint(queue, url_prefix='/rq')
# API does not need CSRF protection
csrf.exempt(api_endpoints)
app.register_blueprint(api_endpoints, url_prefix=API_PREFIX)
return app
from argparse import ArgumentParser
from flask import Flask
from server.app import AppConfig
from server.models import db
"""
Creates the database if it does not already exist and creates all the tables inside if it
Can be run with the --delete command line flag to empty the existing database
"""
if __name__ == '__main__':
parser = ArgumentParser()
parser.add_argument(
'--delete',
help="DELETES ALL DATA in the database and starts over",
action='store_true')
drop_all = parser.parse_args().delete
app = Flask(__name__)
app.config.from_object(AppConfig())
db.init_app(app)
with app.app_context():
if drop_all:
db.drop_all()
db.create_all()
from flask import Flask, render_template, jsonify, request
from server.models import db, Entry, EntrySchema, EntryFactory
from datetime import datetime
import os
from pprint import pprint
app = Flask(__name__)
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
db_path = os.path.join(BASE_DIR, 'flaskstream.db')
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + db_path
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
app.config['DEBUG'] = True
db.init_app(app)
entry_schema = EntrySchema()
entries_schema = EntrySchema(many=True, only=('posted', 'text'))
@app.route('/')
def index():
# create_entry()
return render_template('index.html', text='Hello world')
@app.route('/entries', methods=['GET'])
def entries():
entries = Entry.query.order_by(Entry.posted.desc()).all()
result = entries_schema.dump(entries)
out = jsonify({'entries': result.data})
pprint(out.response)
def create_app(environment_name=None):
"""Create and return a Flask application. Reads a config file path from the
OK_SERVER_CONFIG environment variable. If it is not set, it imports and reads
from the config module (using environment_name). This is so we can default to a development
environment locally, but the app will fail in production if there is no
config file rather than dangerously defaulting to a development environment.
"""
app = Flask(__name__)
env_module_path = os.getenv('OK_SERVER_CONFIG',
'server.settings.{}'.format(environment_name))
if '/' in env_module_path:
env_module_path = env_module_path.replace('/', '.')
env_module_path = env_module_path.replace('.py', '')
app.config.from_object(env_module_path + '.Config')
# Set REMOTE_ADDR for proxies
num_proxies = app.config.get('NUM_PROXIES', 0)
if num_proxies:
app.wsgi_app = ProxyFix(app.wsgi_app, num_proxies=num_proxies)
# Sentry Error Reporting
sentry_dsn = os.getenv('SENTRY_DSN')
if not app.debug and sentry_dsn:
sentry.init_app(app, dsn=sentry_dsn)
@app.errorhandler(500)
def internal_server_error(error):
return render_template('errors/500.html',
event_id=g.sentry_event_id,
public_dsn=sentry.client.get_public_dsn('https')
), 500
# Azure Application Insights request and error tracking
appinsights.init_app(app)
@app.errorhandler(404)
def not_found_error(error):
if request.path.startswith("/api"):
return api.handle_error(error)
return render_template('errors/404.html'), 404
@app.route("/healthz")
def health_check():
return 'OK'
@app.after_request
def flush_appinsights_telemetry(response):
appinsights.flush()
return response
@app.context_processor
def inject_root_url():
return {'index_url': app.config['APPLICATION_ROOT']}
# initialize the cache
cache.init_app(app)
# initialize redis task queues
RQ(app)
# Protect All Routes from csrf
csrf.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
# Flask-Login manager
login_manager.init_app(app)
# initalize cloud storage
storage.init_app(app)
# Set up logging
logging.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# custom URL handling
converters.init_app(app)
# custom Jinja rendering
app.jinja_env.globals.update({
'utils': utils,
'debug': app.debug,
'instantclick': app.config.get('INSTANTCLICK', True),
'CSRFForm': CSRFForm
})
app.jinja_env.filters.update({
'markdown': utils.convert_markdown,
'pluralize': utils.pluralize,
})
# register our blueprints
# OAuth should not need CSRF protection
csrf.exempt(auth)
app.register_blueprint(auth)
csrf.exempt(oauth)
app.register_blueprint(oauth)
app.register_blueprint(files)
app.register_blueprint(student)
app.register_blueprint(admin, url_prefix='/admin')
app.register_blueprint(about, url_prefix='/about')
# Redis Queue dashboard
csrf.exempt(queue)
app.register_blueprint(queue, url_prefix='/rq')
# API does not need CSRF protection
csrf.exempt(api_endpoints)
app.register_blueprint(api_endpoints, url_prefix=API_PREFIX)
return app
