def make_env(app):
# environment-based configuration loading
env = Environments(app, var_name="BEAVY_ENV")
env.from_yaml(os.path.join(BASE_DIR, 'config.yml'))
# env.from_yaml(os.path.join(os.getcwd(), 'config.yml'))
with open(os.path.join(os.getcwd(), 'config.yml'), "r") as r:
deepmerge(app.config, yaml.load(r))
# allow for environment variables to update items
if os.environ.get("BEAVY_CONFIG_FROM_ENV", False):
app.config.update(os.environ)
if "DATABASE_URL" in os.environ:
app.config["SQLALCHEMY_DATABASE_URI"] = os.environ["DATABASE_URL"]
if "RABBITMQ_URL" in os.environ:
app.config["CELERY_BROKER_URL"] = os.environ["RABBITMQ_URL"]
if "REDIS_URL" in os.environ:
app.config["RATELIMIT_STORAGE_URL"] = os.environ["REDIS_URL"]
app.config["CACHE_REDIS_URL"] = os.environ["REDIS_URL"]
# update social buttons
_FLBLPRE = "flask_social_blueprint.providers.{}"
if "SOCIAL_BLUEPRINT" not in app.config:
app.config["SOCIAL_BLUEPRINT"] = dict([
("." in name and name or _FLBLPRE.format(name), values)
for name, values in app.config.get("SOCIAL_LOGINS").items()
])
return env
def create_app(package_name,
package_path,
settings_override=None,
settings='settings.yaml'):
"""
Create a L{flask.Flask} application with common configuration applied.
@param package_name: application package name.
@param package_path: package path to search for blueprints.
@param settings: the settings per environment in YAML.
@param settings_override: a dictionary of settings to override.
@return: the Flask application; never C{None}.
"""
app = Flask(package_name, instance_relative_config=True)
env = Environments(app)
env.from_yaml(os.path.join(os.getcwd(), '', settings))
app.config.from_object(settings_override)
logging.basicConfig(level=logging.DEBUG)
register_blueprints(app, package_name, package_path)
return app
def make_env(app):
# environment-based configuration loading
env = Environments(app, var_name="BEAVY_ENV")
env.from_yaml(os.path.join(BASE_DIR, 'config.yml'))
# env.from_yaml(os.path.join(os.getcwd(), 'config.yml'))
with open(os.path.join(os.getcwd(), 'config.yml'), "r") as r:
deepmerge(app.config, yaml.load(r))
# allow for environment variables to update items
if os.environ.get("BEAVY_CONFIG_FROM_ENV", False):
app.config.update(os.environ)
if "DATABASE_URL" in os.environ:
app.config["SQLALCHEMY_DATABASE_URI"] = os.environ["DATABASE_URL"]
if "RABBITMQ_URL" in os.environ:
app.config["CELERY_BROKER_URL"] = os.environ["RABBITMQ_URL"]
if "REDIS_URL" in os.environ:
app.config["RATELIMIT_STORAGE_URL"] = os.environ["REDIS_URL"]
app.config["CACHE_REDIS_URL"] = os.environ["REDIS_URL"]
# update social buttons
_FLBLPRE = "flask_social_blueprint.providers.{}"
if "SOCIAL_BLUEPRINT" not in app.config:
app.config["SOCIAL_BLUEPRINT"] = dict([
("." in name and name or _FLBLPRE.format(name), values)
for name, values in app.config.get("SOCIAL_LOGINS").items()])
return env
def create_app(config_name):
app = Flask(__name__)
env = Environments(app, default_env=config_name)
env.from_yaml(os.path.join(basedir, 'config.yml'))
celery.conf.update(BROKER_URL=app.config['REDIS_URL'],
CELERY_RESULT_BACKEND=app.config['REDIS_URL'])
#Adding logging capabilities.
if app.config['LOGGING'] == True:
import logging
logger = logging.getLogger('replicate')
logger.setLevel(logging.DEBUG)
log_directory = basedir + app.config['LOG_FILE_PTAH']
log_filename = log_directory + app.config['LOG_FILE']
if not os.path.exists(os.path.dirname(log_filename)):
os.makedirs(os.path.dirname(log_filename))
file_handler = logging.FileHandler(log_filename, mode='a+')
stream_handler = logging.StreamHandler()
formatter = logging.Formatter(
'%(asctime)s - %(process)d - %(name)s - %(module)s:%(lineno)d - %(levelname)s - %(message)s'
)
file_handler.setFormatter(formatter)
stream_handler.setFormatter(formatter)
app.logger.addHandler(file_handler)
#app.logger.addHandler(stream_handler)
app.logger.setLevel(logging.DEBUG)
app.logger.info('Application Process Started')
#SSL
if not app.debug and not app.testing and app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
sslify = SSLify(app)
# handle proxy server headers
from werkzeug.contrib.fixers import ProxyFix
app.wsgi_app = ProxyFix(app.wsgi_app)
db.init_app(app)
login_manager.init_app(app)
cache.init_app(app)
csrf.init_app(app)
redis_store.init_app(app)
from ooiservices.app.main import api as main_blueprint
app.register_blueprint(main_blueprint)
from ooiservices.app.uframe import uframe as uframe_blueprint
app.register_blueprint(uframe_blueprint, url_prefix='/uframe')
from ooiservices.app.redmine import redmine as redmine_blueprint
app.register_blueprint(redmine_blueprint, url_prefix='/redmine')
return app
def create_app():
"""Return a Flask app configured for the correct env (test, dev, prod)."""
app = Flask(__name__)
env = Environments(app)
env.from_yaml(os.path.join(os.getcwd(), 'config.yaml'))
api = Api(app)
api.add_resource(PlayerListResource, '/players')
api.add_resource(PlayerResource, '/players/<string:name>')
api.add_resource(GameListResource, '/games')
api.add_resource(ChallengeListResource, '/challenges')
db.init_app(app)
return app
def create_app(config_name):
app = Flask(__name__)
env = Environments(app, default_env=config_name)
app.config.from_object(env.from_yaml('config.yml'))
certfile = app.config['OAUTH_CERTIFICATE_PATH']
with open(certfile, 'r') as contents:
key_contents = contents.read()
key = RSA.importKey(key_contents)
app.oauth_certificate = key.publickey().exportKey()
bootstrap.init_app(app)
db.init_app(app)
mail.init_app(app)
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask_sslify import SSLify
sslify = SSLify(app)
@app.errorhandler(InvalidUsage)
def handle_invalid_usage(error):
response = jsonify(error.to_dict())
response.status_code = error.status_code
return response
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
from .api_1_0 import api as api_1_0_blueprint
app.register_blueprint(api_1_0_blueprint, url_prefix='/api/v1.0')
return app
def make_env(app):
# environment-based configuration loading
env = Environments(app, var_name="BEAVY_ENV")
env.from_yaml(os.path.join(BASE_DIR, 'config.yml'))
env.from_yaml(os.path.join(os.getcwd(), 'config.yml'))
# update social buttons
_FLBLPRE = "flask_social_blueprint.providers.{}"
if not "SOCIAL_BLUEPRINT" in app.config:
app.config["SOCIAL_BLUEPRINT"] = dict([
("." in name and name or _FLBLPRE.format(name), values)
for name, values in app.config.get("SOCIAL_LOGINS").items()
])
return env
def create_app(config_name):
app = Flask(__name__)
env = Environments(app, default_env=config_name)
app.config.from_object(env.from_yaml('config.yml'))
certfile = app.config['OAUTH_CERTIFICATE_PATH']
with open(certfile, 'r') as fd:
kt = fd.read()
key = RSA.importKey(kt)
app.oauth_certificate = key.publickey().exportKey()
bootstrap.init_app(app)
db.init_app(app)
mail.init_app(app)
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask_sslify import SSLify
sslify = SSLify(app)
@app.errorhandler(InvalidUsage)
def handle_invalid_usage(error):
response = jsonify(error.to_dict())
response.status_code = error.status_code
return response
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
from .api_1_0 import api as api_1_0_blueprint
app.register_blueprint(api_1_0_blueprint, url_prefix='/api/v1.0')
return app
def make_env(app):
# environment-based configuration loading
env = Environments(app, var_name="BEAVY_ENV")
env.from_yaml(os.path.join(BASE_DIR, 'config.yml'))
# env.from_yaml(os.path.join(os.getcwd(), 'config.yml'))
with open(os.path.join(os.getcwd(), 'config.yml'), "r") as r:
deepmerge(app.config, yaml.load(r))
# update social buttons
_FLBLPRE = "flask_social_blueprint.providers.{}"
if "SOCIAL_BLUEPRINT" not in app.config:
app.config["SOCIAL_BLUEPRINT"] = dict([
("." in name and name or _FLBLPRE.format(name), values)
for name, values in app.config.get("SOCIAL_LOGINS").items()])
return env
def __init__(self):
super(Main, self).__init__(
__name__,
static_url_path='/res',
static_folder='../webapp/resources',
template_folder='templates')
# Runtime environment (e.g., export FLASK_ENV=PRODUCTION)
# https://pythonhosted.org/Flask-Environments
env = Environments(self)
env.from_yaml(os.path.join(os.getcwd(), 'config/config.yml'))
# Config logging.
# https://docs.python.org/2/howto/logging.html
logging.config.dictConfig(yaml.load(open(self.config['LOG_CONFIG'])))
# Jinja2 templates.
# http://jinja.pocoo.org/docs/dev/api
# http://flask.pocoo.org/docs/0.10/api/#flask.Flask.jinja_options
self.jinja_options = flask.Flask.jinja_options.copy()
self.jinja_options.update(dict(
trim_blocks=True,
lstrip_blocks=True
))
# http://pythonhosted.org/Flask-Session
# http://flask.pocoo.org/docs/0.10/quickstart/#sessions
self.session = Session(self)
# Enable injection within this class.
# https://github.com/alecthomas/injector
injector = Injector()
injector.install_into(self)
# Flask injection.
# NOTE: Order of modules is important.
LOG.info('### %s ###' % self.config['ENVIORNMENT'])
FlaskInjector(app=self, injector=injector, modules=[
ConfigModule,
OAuthConfigModule,
TwitterModule,
ViewModule,
OAuthRouterModule
])
class FlaskEnvironmentsTestCase(unittest.TestCase):
DEFAULT_ENV = None
VAR_NAME = None
DATABASE_VALUE = 'development_db'
def setUp(self):
self.app = Flask(__name__)
self.environments = Environments(self.app,
var_name=self.VAR_NAME,
default_env=self.DEFAULT_ENV)
def test_from_object(self):
self.environments.from_object('tests.config')
self.assertEqual(self.app.config['DATABASE'], self.DATABASE_VALUE)
def test_from_yaml(self):
path = os.path.join(os.getcwd(), 'tests', 'config.yml')
self.environments.from_yaml(path)
self.assertEqual(self.app.config['DATABASE'], self.DATABASE_VALUE)
def create_app(package_name, package_path, settings_override=None, settings='settings.yaml'):
"""
Create a L{flask.Flask} application with common configuration applied.
@param package_name: application package name.
@param settings_override: a dictionary of settings to override.
@return: the Flask application; never C{None}.
"""
app = Flask(package_name, instance_relative_config=True)
env = Environments(app)
env.from_yaml(os.path.join(os.getcwd(), '', settings))
app.config.from_object(settings_override)
logging.basicConfig(level=logging.DEBUG)
register_blueprints(app, package_name, package_path)
register_injection_modules(app, package_name, package_path, settings_override=settings_override)
return app
from flask import Flask
from flask.ext.mongokit import MongoKit
from flask.ext.login import LoginManager
from flask.ext.mail import Mail
from flask_environments import Environments
# Create application object
app = Flask(__name__)
env = Environments(app)
env.from_yaml('config.yml')
# Create logging
if app.config.get('LOG_FILE') == True:
import logging
from logging import FileHandler
file_handler = FileHandler('log.txt')
file_handler.setLevel(logging.INFO)
app.logger.addHandler(file_handler)
# Create the database connection
db = MongoKit(app)
# Create the Redis connection
import redis
from rq import Queue
redis_connection = redis.from_url(app.config.get("REDIS_URL"))
queue = Queue('default', connection=redis_connection, default_timeout=600)
from rq_scheduler import Scheduler
scheduler = Scheduler(queue_name="default", connection=redis_connection)
from flask_injector import FlaskInjector
import os
from config import ConfigModule
from view import ViewModule
import service.twitter
#
# Flask App.
#
app = flask.Flask(__name__, template_folder='templates')
# Runtime environment (FLASK_ENV)
# https://pythonhosted.org/Flask-Environments
env = Environments(app)
env.from_yaml(os.path.join(os.getcwd(), 'config/config.yml'))
# Flask injection modules.
# https://github.com/alecthomas/injector
FlaskInjector(app=app, modules=[
ConfigModule,
ViewModule,
service.twitter.ServiceModule
])
#
# Start-up.
#
if __name__ == '__main__':
app.run(host='0.0.0.0', port=app.config['PORT'])
def create_app(config_name):
app = Flask(__name__)
env = Environments(app, default_env=config_name)
if os.path.exists(os.path.join(basedir, "config_local.yml")):
env.from_yaml(os.path.join(basedir, "config_local.yml"))
else:
env.from_yaml(os.path.join(basedir, "config.yml"))
# Uses REDIS_URL from config.yml to set the connection to the redis-server
cache.config = {"CACHE_TYPE": "redis", "CACHE_REDIS_URL": app.config["REDIS_URL"]}
# Adding logging capabilities.
if app.config["LOGGING"] is True:
import logging
logger = logging.getLogger("replicate")
logger.setLevel(logging.DEBUG)
log_directory = basedir + app.config["LOG_FILE_PTAH"]
log_filename = log_directory + app.config["LOG_FILE"]
if not os.path.exists(os.path.dirname(log_filename)):
os.makedirs(os.path.dirname(log_filename))
file_handler = logging.FileHandler(log_filename, mode="a+")
stream_handler = logging.StreamHandler()
formatter = logging.Formatter(
"%(asctime)s - %(process)d - %(name)s - " + "%(module)s:%(lineno)d - %(levelname)s - %(message)s"
)
file_handler.setFormatter(formatter)
stream_handler.setFormatter(formatter)
app.logger.addHandler(file_handler)
# app.logger.addHandler(stream_handler)
app.logger.setLevel(logging.DEBUG)
app.logger.info("Application Process Started")
# SSL
if not app.debug and not app.testing and app.config["SSL_DISABLE"]:
from flask.ext.sslify import SSLify
sslify = SSLify(app)
# handle proxy server headers
from werkzeug.contrib.fixers import ProxyFix
app.wsgi_app = ProxyFix(app.wsgi_app)
db.init_app(app)
login_manager.init_app(app)
cache.init_app(app)
csrf.init_app(app)
redis_store.init_app(app)
cors.init_app(app)
# Flask-Security Init
from ooiservices.app.models import User, Role
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security = Security(app, user_datastore)
from ooiservices.app.main import api as main_blueprint
app.register_blueprint(main_blueprint)
from ooiservices.app.uframe import uframe as uframe_blueprint
app.register_blueprint(uframe_blueprint, url_prefix="/uframe")
from ooiservices.app.redmine import redmine as redmine_blueprint
app.register_blueprint(redmine_blueprint, url_prefix="/redmine")
from ooiservices.app.alfresco import alfresco as alfresco_blueprint
app.register_blueprint(alfresco_blueprint, url_prefix="/alfresco")
from ooiservices.app.m2m import m2m as m2m_blueprint
app.register_blueprint(m2m_blueprint, url_prefix="/m2m")
# If debug is enabled add route for site-map
if app.config["DEBUG"]:
app.add_url_rule("/site-map", "site_map", site_map)
return app
#!/usr/bin/env python
'''
ooiui.core.app.science
Defines the application for the Science UI
'''
import os
from flask import Flask
from flask.ext.cache import Cache
from flask_environments import Environments
app = Flask(__name__, static_url_path='', template_folder='../../templates', static_folder='../../static')
env = Environments(app, default_env='DEVELOPMENT')
basedir = 'ooiui/config'
if os.path.exists(os.path.join(basedir, 'config_local.yml')):
env.from_yaml(os.path.join(basedir, 'config_local.yml'))
else:
env.from_yaml(os.path.join(basedir, 'config.yml'))
cache = Cache(app, config={'CACHE_TYPE': app.config['CACHE_TYPE']})
app
The application context
'''
from celery import Celery
from celery.schedules import crontab
from flask import Flask, url_for, jsonify
from flask_environments import Environments
import os
celery = Celery('__main__')
app = Flask(__name__, static_folder='web/static')
env = Environments(app, default_env='DEVELOPMENT')
env.from_yaml('config.yml')
# Override config file with local version
if os.path.exists('config.local.yml'):
env.from_yaml('config.local.yml')
celery.conf.update(broker_url=app.config['REDIS_URL'],
result_backend=app.config['REDIS_URL'])
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
# Version 1.0.0-alpha6
import os
import sys
from flask import Flask, jsonify
from flask_environments import Environments
from flask_sqlalchemy import SQLAlchemy
from flask_marshmallow import Marshmallow
from flask_caching import Cache
from flask_cors import cross_origin
from oauth2client.service_account import ServiceAccountCredentials
# instantiate the application
app = Flask(__name__)
env = Environments(app)
env.from_yaml(os.path.join(os.getcwd(), 'conf/main.yml'))
db = SQLAlchemy(app)
ma = Marshmallow(app)
# setup caching
cache = Cache(app,
config={
'CACHE_TYPE':
app.config['CACHE']['TYPE'],
'CACHE_DIR':
os.path.join(os.getcwd(), app.config['CACHE']['DIRECTORY'])
})
@app.errorhandler(404)
@cross_origin()
#!/usr/bin/env python
'''
ooiui.core.app.science
Defines the application for the Science UI
'''
import os
from flask import Flask
from flask.ext.cache import Cache
from flask_environments import Environments
app = Flask(__name__,
static_url_path='',
template_folder='../../templates',
static_folder='../../static')
env = Environments(app, default_env='DEVELOPMENT')
basedir = 'ooiui/config'
if os.path.exists(os.path.join(basedir, 'config_local.yml')):
env.from_yaml(os.path.join(basedir, 'config_local.yml'))
else:
env.from_yaml(os.path.join(basedir, 'config.yml'))
cache = Cache(app, config={'CACHE_TYPE': app.config['CACHE_TYPE']})
from flask import Flask
from flask.ext import admin
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.security import Security, SQLAlchemyUserDatastore
from flask_environments import Environments
import flask_admin
app = Flask(__name__)
env = Environments(app)
ROOT = os.path.dirname(__file__)
CONFIG_YAML = 'config.yaml'
if os.path.exists(op.join(ROOT, 'config.yaml')):
env.from_yaml(op.join(ROOT, 'config.yaml'))
if hasattr(app.config, 'DEBUG_TOOLBAR') and app.config['DEBUG_TOOLBAR']:
from flask_debugtoolbar import DebugToolbarExtension
toolbar = DebugToolbarExtension(app)
db = SQLAlchemy(app)
# Custom login.
@app.route('/login', methods=['GET', 'POST'])
def login():
"""Must be defined upper setup flask-security."""
from budgetfamily.auth.views import flask_login
return flask_login()
""" Mail reader and pase images linkg generate database and download images
"""
import os
from flask import Flask
from flask.ext.cors import CORS
from flask_environments import Environments
from flask.ext.pymongo import PyMongo
app = Flask(__name__)
app.name = 'Mailer'
env = Environments(app)
config_file = os.path.join(os.path.abspath('./app'), 'config', 'config.yml')
secrets_file = os.path.join(os.path.abspath('./app'), 'config', 'secrets.yml')
env.from_yaml(config_file)
env.from_yaml(secrets_file)
mongo = PyMongo(app)
CORS(app)
app.jinja_env.line_statement_prefix = '%'
from app import routers
# Copyright 2014 MongoDB, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
from flask import Flask
from flask_environments import Environments
from pymongo import MongoClient
app = Flask(__name__)
env = Environments(app)
env.from_yaml(os.path.join(os.path.abspath(os.path.join('..', os.path.dirname(__file__))), '..', 'config.yaml'))
mongodb = MongoClient(app.config['MONGO_HOST'], app.config['MONGO_PORT'])
db = mongodb[app.config['MONGO_DBNAME']]
import os
from flask import Flask, jsonify
from flask_sqlalchemy import SQLAlchemy
from flask_environments import Environments
from flask.ext.bootstrap import Bootstrap
from jinja2 import Environment, PackageLoader
# init flask app
app = Flask(__name__)
# init db con
db = SQLAlchemy(app)
# configure flask
env = Environments(app)
env.from_yaml(os.path.join(os.getcwd(), 'flaskapi', 'config', 'config.yml'))
# configure jinja
env = Environment(loader=PackageLoader('flaskapi', 'templates'))
env.filters['jsonify'] = jsonify
# bootstrap
bootstrap = Bootstrap(app)
# TODO: configure per environment logging
# app module imports
import models.asset
import controllers.api
import controllers.errors
#!/usr/bin/env python
'''
ooiui.core.app.science
Defines the application for the Science UI
'''
from flask import Flask
from flask.ext.cache import Cache
from flask_environments import Environments
app = Flask(__name__, static_url_path='', template_folder='../../templates', static_folder='../../static')
env = Environments(app, default_env='DEVELOPMENT')
env.from_yaml('ooiui/config/config.yml')
cache = Cache(app, config={'CACHE_TYPE': app.config['CACHE_TYPE']})
Copyright 2015 RPS ASA
See LICENSE.txt
'''
from flask import Flask
from flask_environments import Environments
from flask.ext.sqlalchemy import SQLAlchemy
from flask_restful import Api
from cbibs_api.reverse_proxy import ReverseProxied
import os
app = Flask(__name__)
app.wsgi_app = ReverseProxied(app.wsgi_app)
env = Environments(app)
env.from_yaml('config.yml')
if os.path.exists('config.local.yml'):
env.from_yaml('config.local.yml')
if app.config['LOGGING'] == True:
import logging
logger = logging.getLogger('pyprojects.app')
logger.setLevel(logging.DEBUG)
log_directory = app.config['LOG_FILE_PATH']
log_filename = os.path.join(log_directory,app.config['LOG_FILE'])
if not os.path.exists(os.path.dirname(log_filename)):
os.makedirs(os.path.dirname(log_filename))
file_handler = logging.FileHandler(log_filename, mode='a+')
stream_handler = logging.StreamHandler()
#!/usr/bin/env python
'''
ooiui.core.app.science
Defines the application for the Science UI
'''
from flask import Flask
from flask.ext.cache import Cache
from flask_environments import Environments
app = Flask(__name__,
static_url_path='',
template_folder='../../templates',
static_folder='../../static')
env = Environments(app, default_env='DEVELOPMENT')
env.from_yaml('ooiui/config/config.yml')
cache = Cache(app, config={'CACHE_TYPE': app.config['CACHE_TYPE']})
# Copyright 2014 MongoDB, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
from flask import Flask
from flask_environments import Environments
from pymongo import MongoClient
app = Flask(__name__)
env = Environments(app)
env.from_yaml(
os.path.join(
os.path.abspath(os.path.join('..', os.path.dirname(__file__))), '..',
'config.yaml'))
mongodb = MongoClient(app.config['MONGO_HOST'], app.config['MONGO_PORT'])
db = mongodb[app.config['MONGO_DBNAME']]
def create_app(config_name):
app = Flask(__name__)
env = Environments(app, default_env=config_name)
if os.path.exists(os.path.join(basedir, 'config_local.yml')):
env.from_yaml(os.path.join(basedir, 'config_local.yml'))
else:
env.from_yaml(os.path.join(basedir, 'config.yml'))
celery.conf.update(BROKER_URL=app.config['REDIS_URL'],
CELERY_RESULT_BACKEND=app.config['REDIS_URL'])
#Adding logging capabilities.
if app.config['LOGGING'] == True:
import logging
logger = logging.getLogger('replicate')
logger.setLevel(logging.DEBUG)
log_directory = basedir + app.config['LOG_FILE_PTAH']
log_filename = log_directory + app.config['LOG_FILE']
if not os.path.exists(os.path.dirname(log_filename)):
os.makedirs(os.path.dirname(log_filename))
file_handler = logging.FileHandler(log_filename, mode='a+')
stream_handler = logging.StreamHandler()
formatter = logging.Formatter('%(asctime)s - %(process)d - %(name)s - %(module)s:%(lineno)d - %(levelname)s - %(message)s')
file_handler.setFormatter(formatter)
stream_handler.setFormatter(formatter)
app.logger.addHandler(file_handler)
#app.logger.addHandler(stream_handler)
app.logger.setLevel(logging.DEBUG)
app.logger.info('Application Process Started')
#SSL
if not app.debug and not app.testing and app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
sslify = SSLify(app)
# handle proxy server headers
from werkzeug.contrib.fixers import ProxyFix
app.wsgi_app = ProxyFix(app.wsgi_app)
db.init_app(app)
login_manager.init_app(app)
cache.init_app(app)
csrf.init_app(app)
redis_store.init_app(app)
cors.init_app(app)
from ooiservices.app.main import api as main_blueprint
app.register_blueprint(main_blueprint)
from ooiservices.app.uframe import uframe as uframe_blueprint
app.register_blueprint(uframe_blueprint, url_prefix='/uframe')
from ooiservices.app.redmine import redmine as redmine_blueprint
app.register_blueprint(redmine_blueprint, url_prefix='/redmine')
# If debug is enabled add route for site-map
if app.config['DEBUG']:
app.add_url_rule('/site-map', 'site_map', site_map)
return app
