def create_app(app_config=None):
app = Flask(__name__)
# 读取配置文件
if app_config is None:
env = Environments(app, var_name='env', default_env='None')
env.from_object('app.config')
else:
app.config.from_object(configs[app_config])
# 蓝图注册
register_blueprints(app)
# 扩展注册
register_extensions(app)
# 自定义日期格式，待修改
datetime_format = app.config.get('APIZEN_DATETIME_FMT',
'%Y/%m/%d %H:%M:%S')
CustomJSONEncoder.datetime_format = datetime_format
app.json_encoder = CustomJSONEncoder
@app.route('/', methods=['GET'])
def index():
return '<h1>请直接调用接口</h1>'
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)
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 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 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 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 __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
])
def create_app():
"""
This method create the Flask application.
:return: Flask App Object
"""
global app
global login
app = Flask(__name__, instance_relative_config=True)
flask_env = os.getenv('FLASK_ENV', 'None')
if flask_env == 'development':
config_object = 'config.DevConfig'
elif flask_env == 'testing':
config_object = 'config.TestConfig'
elif flask_env == 'production':
config_object = 'config.ProdConfig'
else:
raise RuntimeError(
"%s is not recognized as valid app environment. You have to setup the environment!"
% flask_env)
# Load config
env = Environments(app)
env.from_object(config_object)
# Configuring redis
create_redis(app)
register_extensions(app)
register_blueprints(app)
register_handlers(app)
# loading login manager
import gooutsafe.auth.login_manager as lm
login = lm.init_login_manager(app)
if flask_env == 'testing' or flask_env == 'development':
register_test_blueprints(app)
return app
def create_app_api():
app = Flask(SERVICE_NAME)
config_env = Environments(app, default_env="DEVELOPMENT")
config_env.from_object('config')
config_redis_ipport = app.config["CONFIG_REDIS_IPPORT"]
config_redis_password = app.config["CONFIG_REDIS_PWD"]
app.config[
'REDIS_URL'] = "redis://:" + config_redis_password + "@" + config_redis_ipport + "/7"
redisService.init_app(app)
api_plus = Api(app,
version="v1.0.0",
title=SERVICE_NAME,
prefix=APP_URL_PREFIX)
# 首先打开（或创建）一个scheduler.lock文件，并加上非阻塞互斥锁。成功后创建scheduler并启动。
f = open("scheduler.lock", "wb")
try:
fcntl.flock(f, fcntl.LOCK_EX | fcntl.LOCK_NB)
scheduler = APScheduler()
scheduler.init_app(app)
scheduler.start()
except:
# 如果加文件锁失败，说明scheduler已经创建，就略过创建scheduler的部分。
pass
# 最后注册一个退出事件，如果这个flask项目退出，则解锁并关闭scheduler.lock文件的锁。
def unlock():
fcntl.flock(f, fcntl.LOCK_UN)
f.close()
atexit.register(unlock)
BASIC_URL_PREFIX = "/basic" # stellar基础接口(用户、区块浏览器等相关)
api_plus.add_namespace(basic_ns, BASIC_URL_PREFIX)
return app, api_plus
def create_app():
"""
This method create the Flask application.
:return: Flask App Object
"""
global db
global app
global api_app
global celery
# first initialize the logger
init_logger()
api_app = connexion.FlaskApp(
__name__,
server='flask'
)
# getting the flask app
app = api_app.app
flask_env = os.getenv('FLASK_ENV', 'None')
if flask_env == 'development':
config_object = 'config.DevConfig'
elif flask_env == 'testing':
config_object = 'config.TestConfig'
elif flask_env == 'production':
config_object = 'config.ProdConfig'
else:
raise RuntimeError(
"%s is not recognized as valid app environment. You have to setup the environment!" % flask_env)
# Load config
env = Environments(app)
env.from_object(config_object)
# creating celery
celery = make_celery(app)
# loading communications
import gooutsafe.comm as comm
#if flask_env != 'testing':
comm.init_rabbit_mq()
"""else:
comm.disabled = True"""
if flask_env != 'production':
# disable communication for testing purposes
comm.disabled = True
else:
comm.init_rabbit_mq()
db = MongoEngine(
app=app
)
# requiring the list of models
import gooutsafe.models
# registering to api app all specifications
register_specifications(api_app)
return app
from flask_environments import Environments
from app.css_assets import non_admin_css_files, admin_css_files, gallery_css_files
from app.js_assets import non_admin_js_files, admin_js_files, gallery_js_files
# Create app
GisApp = Flask(__name__)
Bootstrap(GisApp)
# for using jQuery 2 from cdn instead of jQuery 1
# (https://github.com/mbr/flask-bootstrap/blob/master/docs/faq.rst#how-can-i-use-jquery2-instead-of-jquery1)
GisApp.extensions['bootstrap']['cdns']['jquery'] = WebCDN(
'//cdnjs.cloudflare.com/ajax/libs/jquery/2.2.1/')
# GisApp.config.from_object('config')
db = SQLAlchemy(GisApp)
env = Environments(GisApp)
env.from_object('config')
# Assets
assets = Environment(GisApp)
js = Bundle(*non_admin_js_files, filters='jsmin', output='gen/packed.js')
admin_js = Bundle(*admin_js_files,
filters='jsmin',
output='gen/admin_packed.js')
gallery_js = Bundle(*gallery_js_files,
filters='jsmin',
output='gen/gallery_packed.js')
assets.register('application_js', js)
assets.register('admin_application_js', admin_js)
import logging
from logging.handlers import RotatingFileHandler
from celery import Celery
from flask import Flask
from flask_environments import Environments
from flask_mongoengine import MongoEngine
from celery.signals import before_task_publish, task_prerun, task_success, task_failure
import mongoengine
from datetime import datetime
import pytz
from config import celery_config
from db.mongo_models import task_monitor
app = Flask(__name__)
env = Environments(app)
env.from_object('config.flask_config')
basedir = os.path.abspath(
os.path.join(os.path.dirname(__file__),
os.path.pardir)) # os.path.abspath(os.path.dirname(__file__))
file_handler = RotatingFileHandler(basedir + "/logs/logger_flask.log",
encoding='utf-8')
formatter = logging.Formatter("%(asctime)s\t%(levelname)s\t%(message)s")
file_handler.setFormatter(formatter)
# 初始化mongodb
monogo_conn = MongoEngine()
monogo_conn.init_app(app)
flask_celery = Celery(app.name, broker=celery_config.CELERY_BROKER_URL)
# import sys
# print(os.path.dirname(__file__))
# print(os.path.dirname(os.path.abspath(__file__)))
# sys.path.append(os.path.dirname(__file__))
# sys.path.append(os.path.dirname(os.path.abspath(__file__)))
# print(sys.path)
from app import init_beas_when_app_start
from app.soda_log import init_log
from app.visualization.soda_visualization_api import base_ns
from app.common.soda_common import SDCommonJsonRet, SDResource, SDCodeMsg, SDRequestParser
from app import sodaVisualizationService
SERVICE_NAME = "soda_potentialpie_pyservice"
APP_URL_PREFIX = "/v1/api/soda"
app = Flask(SERVICE_NAME)
config_env = Environments(app,default_env="DEVELOPMENT")
config_env.from_object('config')
# 日志
init_log()
#加载配置 生产对应环境（生产／开发）的bean
init_beas_when_app_start(app)
api_plus = Api(app,version="v1.0.0",title=SERVICE_NAME,prefix=APP_URL_PREFIX)
#基础接口
BASE_URL_PREFIX = "/base"
'''
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):
from flask.ext import login
from flask.ext.admin.base import MenuLink, Admin, BaseView, expose
from flask.ext.admin.contrib import sqla
from wtforms import PasswordField
import os
from collections import OrderedDict
from datetime import datetime
from redis import Redis
from flask.ext.admin.contrib import rediscli
# Create app
app = Flask(__name__)
# Import the config.yml or config_local.yml file and load it into the app environment
basedir = os.path.abspath(os.path.dirname(__file__))
env = Environments(app, default_env='PRODUCTION')
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'))
# Setup mail functionality
mail = Mail(app)
# Create database connection object
db = SQLAlchemy(app)
# These classes are from ooi-ui-services, slightly modified
# TODO: Figure out a way to keep these classes maintained with ooi-ui-services
from flask_environments import Environments
from flask_migrate import Migrate
from api.blueprints import register_blueprints as register_api_blueprints
from auth.auth import register_login_logout
from auth.blueprints import register_blueprints as register_auth_blueprints
from common.errors import init_error_handlers
from common.resources import Api
from common.schemas import marshmallow
from database import models # noqa ## so alembic is aware of all the models
from database import db
from database.db import setup_pg_extensions
api = Api()
cors = CORS(resources={r"/*": {"origins": "*"}})
env = Environments()
migrate = Migrate(compare_type=True)
oauth = OAuth()
def init_plugins(app):
"""Initialise plugins that need to run BEFORE app context is activated
Args:
app: flask app with no activated context
"""
from database import models # noqa
env.init_app(app)
api.init_app(app)
marshmallow.init_app(app)
cors.init_app(app)
import osmapi
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
from flask_bootstrap import Bootstrap
from flask_environments import Environments
# Create app
GisGeneratorApp = Flask(__name__)
Bootstrap(GisGeneratorApp)
# GisApp.config.from_object('config')
db = SQLAlchemy(GisGeneratorApp)
env = Environments(GisGeneratorApp)
env.from_object('config')
# Load Routes
from app import routes
# configure OSM Api
GisGeneratorApp.osmApiClient = osmapi.OsmApi(
api=GisGeneratorApp.config['OSMAPI_CONFIG']['domain'],
username=GisGeneratorApp.config['OSMAPI_CONFIG']['username'],
password=GisGeneratorApp.config['OSMAPI_CONFIG']['password']
)
def create_app():
"""
This method create the Flask application.
:return: Flask App Object
"""
global db
global app
global migrate
global login
global celery
app = Flask(__name__, instance_relative_config=True)
flask_env = os.getenv('FLASK_ENV', 'None')
if flask_env == 'development':
config_object = 'config.DevConfig'
elif flask_env == 'testing':
config_object = 'config.TestConfig'
elif flask_env == 'production':
config_object = 'config.ProdConfig'
else:
raise RuntimeError(
"%s is not recognized as valid app environment. You have to setup the environment!" % flask_env)
# Load config
env = Environments(app)
env.from_object(config_object)
# registering db
db = SQLAlchemy(
app=app
)
# creating celery
celery = make_celery(app)
# requiring the list of models
register_extensions(app)
register_blueprints(app)
register_handlers(app)
# loading login manager
import gooutsafe.auth as auth
login = auth.init_login_manager(app)
# creating migrate
migrate = Migrate(
app=app,
db=db
)
# checking the environment
if flask_env == 'testing':
# we need to populate the db
db.create_all()
if flask_env == 'testing' or flask_env == 'development':
register_test_blueprints(app)
return app
def create_app():
"""
This method create the Flask application.
:return: Flask App Object
"""
global db
global app
global migrate
global api_app
# first initialize the logger
init_logger()
api_app = connexion.FlaskApp(
__name__,
server='flask',
specification_dir='openapi/',
)
# getting the flask app
app = api_app.app
flask_env = os.getenv('FLASK_ENV', 'None')
if flask_env == 'development':
config_object = 'config.DevConfig'
elif flask_env == 'testing':
config_object = 'config.TestConfig'
elif flask_env == 'production':
config_object = 'config.ProdConfig'
else:
raise RuntimeError(
"%s is not recognized as valid app environment. You have to setup the environment!" % flask_env)
# Load config
env = Environments(app)
env.from_object(config_object)
# creating redis instance
create_redis(app)
# loading communications
import gooutsafe.comm as comm
if flask_env != 'production':
# disable communication for testing purposes
comm.disabled = True
else:
comm.init_rabbit_mq(app)
# registering db
db = SQLAlchemy(
app=app
)
# requiring the list of models
import gooutsafe.models
# creating migrate
migrate = Migrate(
app=app,
db=db
)
# checking the environment
if flask_env == 'testing':
# we need to populate the db
db.create_all()
# registering to api app all specifications
register_specifications(api_app)
return app
from flask import Flask, render_template
from flask_environments import Environments
app = Flask(__name__)
# Recuperation des données de paramétrages de l'application
# Shell variable creation : $ export FLASK_ENV="DevelopmentConfig"
# TODO : [MODERNISATION] utilisation d'un fichier YAML
env = Environments(app, var_name='FLASK_ENV', default_env='TestConfig')
env.from_object('config')
from app.utils import logmanager
def create_app(broker_start=False, log_level=logging.ERROR):
"""
This method create the Flask application.
:return: Flask App Object
"""
global db
global app
global migrate
global login
api_app = connexion.App(__name__,
server='flask',
specification_dir='openapi/')
# getting the flask app
app = api_app.app
flask_env = os.getenv('FLASK_ENV', 'None')
if flask_env == 'development':
config_object = 'config.DevConfig'
elif flask_env == 'testing':
config_object = 'config.TestConfig'
elif flask_env == 'production':
config_object = 'config.ProdConfig'
else:
raise RuntimeError(
"%s is not recognized as valid app environment. You have to setup the environment!"
% flask_env)
# Load config
env = Environments(app)
env.from_object(config_object)
# configuring logging
logging.basicConfig(level=log_level)
# loading communications
import gooutsafe.comm as comm
if broker_start:
if flask_env != 'testing':
comm.init_rabbit_mq(app)
else:
comm.disabled = True
# registering db
db = SQLAlchemy(app=app)
# importing models
try:
import gooutsafe.models.reservation
except ImportError:
raise RuntimeError('Cannot import the models!')
# creating migrate
migrate = Migrate(app=app, db=db)
# checking the environment
if flask_env == 'testing':
# we need to populate the db
db.create_all()
# registering to api app all specifications
register_specifications(api_app)
return app
