def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app, config_name)
assets.init_app(app)
bootstrap.init_app(app)
db.init_app(app)
login_manager.init_app(app)
assets_config = os.path.join(os.path.dirname(__file__), os.pardir,
'webassets.yaml')
assets._named_bundles = {} # avoid duplicate registration in unit tests
assets_loader = YAMLLoader(assets_config)
bundles = assets_loader.load_bundles(assets)
assets.register(bundles)
if not app.debug and not app.testing and app.config[
'SSL_STATUS'] == SSLStatus.ENABLED:
sslify = SSLify(app)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint)
return app
def register_decanter_assets(self):
path = os.path.join(DIR, 'assets', 'decanter.yaml')
if not os.path.isfile(path):
self._write_decanter_manifest(path)
manifest = YAMLLoader(path)
manifest = manifest.load_bundles()
[self.register_asset_bundle(n, manifest[n]) for n in manifest]
def init_assets(app):
app.assets = Environment(app)
app.assets.auto_build = False
app.assets.directory = os.path.join(DIR, 'assets')
app.assets.manifest = 'file'
app.assets.url = '/static'
manifest = YAMLLoader(os.path.join(DIR, 'assets', 'manifest.yaml'))
manifest = manifest.load_bundles()
[app.assets.register(n, manifest[n]) for n in manifest]
def init_assets(app):
app.assets = Environment(app)
app.assets.auto_build = False
app.assets.directory = os.path.join(DIR, 'assets')
app.assets.manifest = 'file'
app.assets.url = '/static'
manifest = YAMLLoader(os.path.join(DIR, 'assets', 'manifest.yaml'))
manifest = manifest.load_bundles()
[app.assets.register(n, manifest[n]) for n in manifest]
def includeme(config):
"""pyramid include. declare the add_thumb_view"""
here = os.path.dirname(__file__)
settings = config.registry.settings
config_dir = settings.get('garasu_webassets.config', '{}/configs'.format(here))
LOG.debug(config_dir)
# config_dir = AssetResolver(None).resolve(config_dir).abspath()
asset_dir = settings.get('garasu_webassets.assets', '{}/assets'.format(here))
LOG.debug(asset_dir)
# asset_dir = AssetResolver(None).resolve(asset_dir).abspath()
env = Environment(directory=asset_dir, url=settings['garasu_webassets.url'])
env.manifest = settings['garasu_webassets.manifest']
env.debug = asbool(settings['garasu_webassets.debug'])
env.cache = asbool(settings['garasu_webassets.cache'])
env.auto_build = asbool(settings['garasu_webassets.auto_build'])
def text(value):
if type(value) is six.binary_type:
return value.decode('utf-8')
else:
return value
def yaml_stream(fname, mode):
if path.exists(fname):
return open(fname, mode)
raise FileNotFoundError
fin = fileinput.input('/'.join([config_dir, settings['garasu_webassets.bundles']]),
openhook=yaml_stream)
with closing(fin):
lines = [text(line).rstrip() for line in fin]
stream_yaml = six.StringIO('\n'.join(lines))
loader = YAMLLoader(stream_yaml)
result = loader.load_bundles()
env.register(result)
# for item in env:
# LOG.debug(item.output)
# path_file = '/'.join([public_dir, item.output])
# src_file = '/'.join([asset_dir, item.output])
# shutil.copy(src_file, path_file)
def _get_assets(request, *args, **kwargs):
bundle = Bundle(*args, **kwargs)
with bundle.bind(env):
urls = bundle.urls()
return urls
config.add_request_method(_get_assets, 'web_assets')
def _get_assets_env(request):
return env
config.add_request_method(_get_assets_env, 'web_env', reify=True)
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app, config_name)
app.config['ASSETS_DEBUG'] = app.config['DEBUG']
assets.init_app(app)
bootstrap.init_app(app)
db.init_app(app)
login_manager.init_app(app)
migrate.init_app(app, db)
assets_config = os.path.join(os.path.dirname(__file__), os.pardir, 'webassets.yaml')
assets._named_bundles = {} # avoid duplicate registration in unit tests
assets_loader = YAMLLoader(assets_config)
bundles = assets_loader.load_bundles(assets)
assets.register(bundles)
if not app.debug and not app.testing and app.config['SSL_STATUS'] == SSLStatus.ENABLED:
sslify = SSLify(app)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint)
@app.context_processor
def bokeh_resources():
return dict(bokeh_resources=CDN)
@app.cli.command()
def flyway():
# parse the database URI
url = make_url(app.config['SQLALCHEMY_DATABASE_URI'])
jdbc_url = 'jdbc:{drivername}://{host}:{port}/{database}'.format(drivername=url.drivername,
host=url.host,
port=url.port if url.port else 3306,
database=url.database)
username = url.username
password = url.password
# get Flyway command to run
settings = Config.settings(os.environ['FLASK_CONFIG'])
args = [settings['flyway_command'],
'-url=' + jdbc_url,
'-user='******'-password='******'-locations=filesystem:' + settings['migration_sql_dir'],
'migrate']
return subprocess.call(args)
return app
def load_bundles(self, bundle_file):
"""
Load predefined bundles from a YAML file.
See bundles.yaml for an example.
"""
# Load bundles from YAML file
loader = YAMLLoader(bundle_file)
bundles = loader.load_bundles()
# Register the bundles with the environment
self.register(bundles)
def configure_static_assets(app):
loader = YAMLLoader('assets.yaml')
assets = Environment(app)
assets.manifest = None
assets.cache = False
assets.directory = './makers'
assets.url = ''
for name, bundle in loader.load_bundles().items():
assets.register(name, bundle)
app.environment = assets
def get_webassets_env(conf):
'''Get a preconfigured WebAssets environment'''
# Configure webassets
assets_environment = AssetsEnvironment(conf.get('static_files_dir', DEFAULT_STATIC), '/')
assets_environment.debug = conf.get('debug', False)
assets_environment.auto_build = conf.get('debug', False)
assets_environment.config['less_paths'] = (
'bower/bootstrap/less',
'bower/etalab-assets/less',
'bower/bootstrap-markdown/less',
)
# Load bundle from yaml file
loader = YAMLLoader(resource_stream(__name__, '../assets.yaml'))
bundles = loader.load_bundles()
for name, bundle in bundles.items():
assets_environment.register(name, bundle)
return assets_environment
def get_webassets_env(base_dir, assets_url, debug=False):
"""
Get a webassets environment configured for building browser extensions.
:param base_dir: The directory into which the assets should be built.
:param assets_url: The relative or absolute URL used to reference assets
in the app.html and embed.js files.
:param debug: If true, generates source maps and skips minification.
"""
webassets_env = webassets.Environment(
directory=os.path.abspath(base_dir),
url=assets_url)
# Disable webassets caching and manifest generation
webassets_env.cache = False
webassets_env.manifest = False
webassets_env.resolver = Resolver()
webassets_env.config['UGLIFYJS_BIN'] = './node_modules/.bin/uglifyjs'
webassets_env.debug = debug
loader = YAMLLoader(resolve('h:assets.yaml').abspath())
webassets_env.register(loader.load_bundles())
return webassets_env
def create_app(
version_path,
secret_key,
session_cookie_name,
session_cookie_domain,
session_cookie_secure,
use_https,
enable_asset_pipeline,
lando_api_url,
debug=False,
):
"""
Create an app instance.
"""
csp = {
"default-src": "'self'",
"font-src": "'self' https://code.cdn.mozilla.net",
"style-src": "'self' https://code.cdn.mozilla.net",
"img-src": "'self' *.cloudfront.net *.gravatar.com " "*.googleusercontent.com",
"object-src": "'none'",
"frame-ancestors": "'none'",
"manifest-src": "'none'",
"worker-src": "'none'",
"media-src": "'none'",
"frame-src": "'none'",
"base-uri": "'none'",
"report-uri": "/__cspreport__",
} # yapf: disable
initialize_logging()
app = Flask(__name__)
app.debug = debug
# Set configuration
version_info = get_app_version(version_path)
logger.info("application version", extra=version_info)
initialize_sentry(app, version_info["version"])
set_config_param(app, "LANDO_API_URL", lando_api_url)
set_config_param(app, "BUGZILLA_URL",
_lookup_service_url(lando_api_url, "bugzilla"))
set_config_param(app, "PHABRICATOR_URL",
_lookup_service_url(lando_api_url, "phabricator"))
set_config_param(app, "SECRET_KEY", secret_key, obfuscate=True)
set_config_param(app, "SESSION_COOKIE_NAME", session_cookie_name)
set_config_param(app, "SESSION_COOKIE_DOMAIN", session_cookie_domain)
set_config_param(app, "SESSION_COOKIE_SECURE", session_cookie_secure)
set_config_param(app, "SERVER_NAME", session_cookie_domain)
set_config_param(app, "USE_HTTPS", use_https)
app.config["PREFERRED_URL_SCHEME"] = "https" if use_https else "http"
app.config["VERSION"] = version_info
# Flags that need to be deprecated in the future.
set_config_param(app, "ENABLE_SEC_APPROVAL",
bool(os.getenv("ENABLE_SEC_APPROVAL")))
set_config_param(
app,
"ENABLE_EMBEDDED_TRANSPLANT_UI",
bool(os.getenv("ENABLE_EMBEDDED_TRANSPLANT_UI")),
)
Talisman(app, content_security_policy=csp, force_https=use_https)
# Authentication
global oidc
authentication = auth.OpenIDConnect(auth.OIDCConfig())
oidc = authentication.auth(app)
# Register routes via Flask Blueprints
from landoui.pages import pages
from landoui.revisions import revisions
from landoui.dockerflow import dockerflow
app.register_blueprint(pages)
app.register_blueprint(revisions)
app.register_blueprint(dockerflow)
# Register template helpers
from landoui.template_helpers import template_helpers
app.register_blueprint(template_helpers)
# Register error pages
errorhandlers.register_error_handlers(app)
# Setup Flask Assets
assets = Environment(app)
if enable_asset_pipeline:
loader = YAMLLoader(
os.path.join(os.path.dirname(os.path.abspath(__file__)),
"assets_src/assets.yml"))
assets.register(loader.load_bundles())
logger.info("Application started successfully.")
return app
def register_assets(self):
manifest = YAMLLoader(os.path.join(self.project_root,
'assets',
'manifest.yaml'))
manifest = manifest.load_bundles()
[self.register_asset_bundle(n, manifest[n]) for n in manifest]
__author__ = 'hsk81'
###############################################################################
###############################################################################
from flask.ext.assets import Environment
from webassets.loaders import YAMLLoader
from ..app import app
###############################################################################
###############################################################################
loader = YAMLLoader (app.config['YML_FILE'])
bundles = loader.load_bundles ()
assets = Environment (app)
assets.manifest = 'cache'
assets.register (bundles)
assets.url = app.config.get ('CDN')
###############################################################################
###############################################################################
def create_app(version_path, secret_key, session_cookie_name,
session_cookie_domain, session_cookie_secure, use_https,
enable_asset_pipeline, lando_api_url):
"""
Create an app instance.
"""
csp = {
'default-src': "'self'",
'font-src': "'self' https://code.cdn.mozilla.net",
'style-src': "'self' https://code.cdn.mozilla.net",
'img-src': "'self' *.cloudfront.net *.gravatar.com "
"*.googleusercontent.com",
'object-src': "'none'",
'frame-ancestors': "'none'",
'manifest-src': "'none'",
'worker-src': "'none'",
'media-src': "'none'",
'frame-src': "'none'",
'base-uri': "'none'",
'report-uri': "/__cspreport__"
} # yapf: disable
initialize_logging()
app = Flask(__name__)
# Set configuration
app.config['VERSION_PATH'] = version_path
log_config_change('VERSION_PATH', version_path)
version_info = json.load(open(version_path))
logger.info(version_info, 'app.version')
this_app_version = version_info['version']
initialize_sentry(app, this_app_version)
app.config['LANDO_API_URL'] = lando_api_url
log_config_change('LANDO_API_URL', lando_api_url)
# Set remaining configuration
app.config['SECRET_KEY'] = secret_key
app.config['SESSION_COOKIE_NAME'] = session_cookie_name
app.config['SESSION_COOKIE_DOMAIN'] = session_cookie_domain
app.config['SESSION_COOKIE_SECURE'] = session_cookie_secure
app.config['SERVER_NAME'] = session_cookie_domain
app.config['USE_HTTPS'] = use_https
app.config['PREFERRED_URL_SCHEME'] = 'https' if use_https else 'http'
Talisman(app, content_security_policy=csp, force_https=use_https)
# Authentication
global oidc
authentication = auth.OpenIDConnect(auth.OIDCConfig())
oidc = authentication.auth(app)
# Register routes via Flask Blueprints
from landoui.pages import pages
from landoui.revisions import revisions
from landoui.dockerflow import dockerflow
app.register_blueprint(pages)
app.register_blueprint(revisions)
app.register_blueprint(dockerflow)
# Register template helpers
from landoui.template_helpers import template_helpers
app.register_blueprint(template_helpers)
# Register error pages
errorhandlers.register_error_handlers(app)
# Setup Flask Assets
assets = Environment(app)
if enable_asset_pipeline:
loader = YAMLLoader(
os.path.join(os.path.dirname(os.path.abspath(__file__)),
'assets_src/assets.yml'))
assets.register(loader.load_bundles())
return app
def get_webassets_env_from_settings(settings, prefix='webassets'):
"""This function will take all webassets.* parameters, and
call the ``Environment()`` constructor with kwargs passed in.
The only two parameters that are not passed as keywords are:
* base_dir
* base_url
which are passed in positionally.
Read the ``WebAssets`` docs for ``Environment`` for more details.
"""
# Make a dictionary of the webassets.* elements...
kwargs = {} # assets settings
cut_prefix = len(prefix) + 1
for k in settings:
if k.startswith(prefix):
val = settings[k]
if isinstance(val, six.string_types):
if val.lower() in auto_booly:
val = asbool(val)
elif val.lower().startswith('json:') and k[cut_prefix:] != 'manifest':
val = json.loads(val[5:])
kwargs[k[cut_prefix:]] = val
if 'base_dir' not in kwargs:
raise Exception("You need to provide webassets.base_dir in your configuration")
if 'base_url' not in kwargs:
raise Exception("You need to provide webassets.base_url in your configuration")
asset_dir = kwargs.pop('base_dir')
asset_url = kwargs.pop('base_url')
if ':' in asset_dir:
try:
asset_dir = AssetResolver(None).resolve(asset_dir).abspath()
except ImportError:
pass
if 'debug' in kwargs:
kwargs['debug'] = maybebool(kwargs['debug'])
if 'cache' in kwargs:
cache = kwargs['cache'] = maybebool(kwargs['cache'])
if cache and isinstance(cache, six.string_types) and not path.isdir(cache):
makedirs(cache)
# 'updater' is just passed in...
if 'auto_build' in kwargs:
kwargs['auto_build'] = maybebool(kwargs['auto_build'])
if 'jst_compiler' in kwargs:
kwargs['JST_COMPILER'] = kwargs.pop('jst_compiler')
if 'jst_namespace' in kwargs:
kwargs['JST_NAMESPACE'] = kwargs.pop('jst_namespace')
if 'manifest' in kwargs:
kwargs['manifest'] = maybebool(kwargs['manifest'])
if 'url_expire' in kwargs:
kwargs['url_expire'] = maybebool(kwargs['url_expire'])
if 'static_view' in kwargs:
kwargs['static_view'] = asbool(kwargs['static_view'])
else:
kwargs['static_view'] = False
if 'cache_max_age' in kwargs:
kwargs['cache_max_age'] = int(kwargs.pop('cache_max_age'))
else:
kwargs['cache_max_age'] = None
if 'load_path' in kwargs:
# force load_path to be an array and split on whitespace
if not isinstance(kwargs['load_path'], list):
kwargs['load_path'] = kwargs['load_path'].split()
paths = kwargs.pop('paths', None)
if 'bundles' in kwargs:
if isinstance(kwargs['bundles'], six.string_types):
kwargs['bundles'] = kwargs['bundles'].split()
bundles = kwargs.pop('bundles', None)
assets_env = Environment(asset_dir, asset_url, **kwargs)
if paths is not None:
for map_path, map_url in json.loads(paths).items():
assets_env.append_path(map_path, map_url)
def yaml_stream(fname):
if path.exists(fname):
return open(fname, 'rb')
else:
return assets_env.resolver.resolver.resolve(fname).stream()
if isinstance(bundles, list):
loaded = {}
for bpath in bundles:
with closing(yaml_stream(bpath)) as s:
loader = YAMLLoader(s)
loaded.update(loader.load_bundles())
assets_env.register(loaded)
elif isinstance(bundles, dict):
assets_env.register(bundles)
return assets_env
def add_webassets(config):
loader = YAMLLoader(join(dirname(__file__), 'resources.yaml'))
bundles = loader.load_bundles()
for name in bundles:
config.add_webasset(name, bundles[name])
env = os.environ.get('FLASK_ENV', 'development').lower()
app = Flask(__name__, static_folder='static')
if env == 'development':
app.config.from_object('config.DevelopmentConfig')
from flask_debugtoolbar import DebugToolbarExtension
DebugToolbarExtension(app)
elif env == 'production':
app.config.from_object('config.ProductionConfig')
# Setup database
db = SQLAlchemy(app)
# Setup login manager
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'auth.login'
# Setup assets
assets_env = Environment(app)
yaml_loader = YAMLLoader(current_dir + '/assets.yml')
for name, bundle in yaml_loader.load_bundles().iteritems():
assets_env.register(name, bundle)
# Registering blueprints:
from antiques.core.views import * # noqa
from antiques.auth.views import auth_module # noqa
app.register_blueprint(auth_module, url_prefix='/auth')
__author__ = 'hsk81'
###############################################################################
###############################################################################
from flask.ext.assets import Environment
from webassets.loaders import YAMLLoader
from ..app import app
###############################################################################
###############################################################################
loader = YAMLLoader(app.config['YML_FILE'])
bundles = loader.load_bundles()
assets = Environment(app)
assets.manifest = 'cache'
assets.register(bundles)
assets.url = app.config.get('CDN')
###############################################################################
###############################################################################
def get_webassets_env_from_settings(settings, prefix='webassets'):
"""This function will take all webassets.* parameters, and
call the ``Environment()`` constructor with kwargs passed in.
The only two parameters that are not passed as keywords are:
* base_dir
* base_url
which are passed in positionally.
Read the ``WebAssets`` docs for ``Environment`` for more details.
"""
# Make a dictionary of the webassets.* elements...
kwargs = {} # assets settings
cut_prefix = len(prefix) + 1
for k in settings:
if k.startswith(prefix):
val = settings[k]
if isinstance(val, six.string_types):
if val.lower() in auto_booly:
val = asbool(val)
elif val.lower().startswith('json:') and k[cut_prefix:] != 'manifest':
val = json.loads(val[5:])
kwargs[k[cut_prefix:]] = val
if 'base_dir' not in kwargs:
raise Exception("You need to provide webassets.base_dir in your configuration")
if 'base_url' not in kwargs:
raise Exception("You need to provide webassets.base_url in your configuration")
asset_dir = kwargs.pop('base_dir')
asset_url = kwargs.pop('base_url')
if ':' in asset_dir:
try:
asset_dir = AssetResolver(None).resolve(asset_dir).abspath()
except ImportError:
pass
if 'debug' in kwargs:
kwargs['debug'] = maybebool(kwargs['debug'])
if 'cache' in kwargs:
cache = kwargs['cache'] = maybebool(kwargs['cache'])
if cache and isinstance(cache, six.string_types) and not path.isdir(cache):
makedirs(cache)
# 'updater' is just passed in...
if 'auto_build' in kwargs:
kwargs['auto_build'] = maybebool(kwargs['auto_build'])
if 'jst_compiler' in kwargs:
kwargs['JST_COMPILER'] = kwargs.pop('jst_compiler')
if 'jst_namespace' in kwargs:
kwargs['JST_NAMESPACE'] = kwargs.pop('jst_namespace')
if 'manifest' in kwargs:
kwargs['manifest'] = maybebool(kwargs['manifest'])
if 'url_expire' in kwargs:
kwargs['url_expire'] = maybebool(kwargs['url_expire'])
if 'static_view' in kwargs:
kwargs['static_view'] = asbool(kwargs['static_view'])
else:
kwargs['static_view'] = False
if 'cache_max_age' in kwargs:
kwargs['cache_max_age'] = int(kwargs.pop('cache_max_age'))
else:
kwargs['cache_max_age'] = None
if 'load_path' in kwargs:
# force load_path to be an array and split on whitespace
if not isinstance(kwargs['load_path'], list):
kwargs['load_path'] = kwargs['load_path'].split()
paths = kwargs.pop('paths', None)
if 'bundles' in kwargs:
if isinstance(kwargs['bundles'], six.string_types):
kwargs['bundles'] = kwargs['bundles'].split()
bundles = kwargs.pop('bundles', None)
assets_env = Environment(asset_dir, asset_url, **kwargs)
if paths is not None:
for map_path, map_url in json.loads(paths).items():
assets_env.append_path(map_path, map_url)
def yaml_stream(fname):
if path.exists(fname):
return open(fname, 'rb')
else:
return assets_env.resolver.resolver.resolve(fname).stream()
if isinstance(bundles, list):
loaded = {}
for bpath in reversed(bundles):
with closing(yaml_stream(bpath)) as s:
loader = YAMLLoader(s)
loaded.update(loader.load_bundles())
assets_env.register(loaded)
elif isinstance(bundles, dict):
assets_env.register(bundles)
return assets_env
