Ejemplo n.º 1
0
def create_app(debug=True):
    """Create an application."""

    app = Flask(__name__)
    logging.basicConfig(
        filename="var/log/newsletter_dispatcher.log",
        level=logging.INFO,
        format="[%(asctime)s] %(levelname)s - %(message)s",
    )
    try:
        app.config.from_object("config.Config")
    except ImportStringError:
        logger.error(
            "No config.py file found. Starting with standard configuration.")

    if app.config.get("SENTRY_DSN", ""):
        sentry_sdk.init(
            dsn=app.config.get("SENTRY_DSN", ""),
            integrations=[FlaskIntegration()],
            # debug=True,
        )

    app.config["TESTING"] = testing_enabled()
    if app.config.get("REDIS_PORT", ""):
        app.redis = redis.Redis(port=app.config["REDIS_PORT"])
    else:
        app.redis = redis.Redis()
    app.task_queue = Queue(connection=app.redis, default_timeout=10000)
    app.mail = Mail(app)
    Api(routes_bp)
    app.register_blueprint(routes_bp)

    return app
Ejemplo n.º 2
0
def create_app(redis_conn=None):
    settings_class = os.getenv('APP_SETTINGS', 'config.Config')

    app = Flask(__name__)
    app.config.from_object(settings_class)
    CORS(app, origins=app.config['CORS_ORIGINS'], supports_credentials=True)

    # Redis
    if redis_conn is None:
        import redis
        app.redis = redis.from_url(app.config["REDIS_URL"],
                                   decode_responses=True)
    else:
        app.redis = redis_conn
    redis_map.init_app(app, app.redis)

    # Api
    from api import routes
    routes.init_app(app)
    basic_auth.init_app(app)
    app.logger.setLevel(logging.DEBUG)
    # app.url_map.strict_slashes = False

    # Rate Limiter
    rate_limiter.init_app(app)

    # Webhook
    webhook.init_app(app, app.config['WEBHOOK_URL'])

    # Environment specific
    if settings_class == 'config.Config':
        from apscheduler.schedulers.gevent import GeventScheduler as Scheduler
        bg_jobs.init_app(app, Scheduler)
    elif settings_class == 'config.Develop':
        from api import localtest
        app.register_blueprint(localtest.bp)

        if is_main_workzeug_process():
            from apscheduler.schedulers.background import BackgroundScheduler as Scheduler
            bg_jobs.init_app(app, Scheduler)
    elif settings_class == 'config.Testing':
        pass
    else:
        raise Exception(f'Unknown settings_class: {settings_class}')

    app.logger.info(f'Loaded {settings_class} configuration')

    return app
Ejemplo n.º 3
0
def create_app(config_class):
    app = Flask(__name__)
    app.config.from_object(config_class)

    # Initialize MongoEngine
    try:
        register_connection(alias="default",
                            name=app.config["DB_NAME"],
                            username=app.config["DB_USER"],
                            password=app.config["DB_PASSWORD"],
                            host=app.config["DB_URL"],
                            port=app.config["DB_PORT"])
    except:
        print("Database could not be configured.")
        return None

    nav.init_app(app)

    login_manager.init_app(app)
    bootstrap.init_app(app)

    app.redis = Redis.from_url(app.config['REDIS_URL'])
    app.task_queue = rq.Queue(app.config['REDIS_QUEUE_NAME'],
                              connection=app.redis)

    from app.jobs import bp as jobs_bp
    app.register_blueprint(jobs_bp, url_prefix='')

    from app.web import bp as web_bp
    app.register_blueprint(web_bp, url_prefix='')

    from app.user import bp as user_bp
    app.register_blueprint(user_bp, url_prefix='')

    return app
Ejemplo n.º 4
0
def create_app(config):
    app = Flask(__name__)
    app.config.from_object(config)
    app.url_map.converters['html'] = HTMLConverter

    #session初始化,将session存储到redis中
    Session(app)

    #创建redis存储对象
    redis_store = StrictRedis(host=config.REDIS_HOST, port=config.REDIS_PORT)
    app.redis = redis_store

    # 日志处理
    import logging
    from logging.handlers import RotatingFileHandler
    logging.basicConfig(level=logging.DEBUG)
    file_log_handler = RotatingFileHandler(os.path.join(
        BASE_DIR, "logs/ihome.log"),
                                           maxBytes=1024 * 1024 * 100,
                                           backupCount=10)
    formatter = logging.Formatter(
        '%(levelname)s %(filename)s:%(lineno)d %(message)s')
    file_log_handler.setFormatter(formatter)
    logging.getLogger().addHandler(file_log_handler)

    return app
Ejemplo n.º 5
0
def create_app(config_name='default'):
    app = Flask(__name__)
    app.config.from_object(config[config_name])

    db.init_app(app)
    ma.init_app(app)
    migrate.init_app(app, db)
    login.init_app(app)
    moment.init_app(app)
    babel.init_app(app)
    api.init_app(app)
    app.elasticsearch = Elasticsearch([app.config['ELASTICSEARCH_URL']]) \
        if app.config['ELASTICSEARCH_URL'] else None
    app.redis = Redis.from_url(app.config['REDIS_URL'])
    app.task_queue = rq.Queue('feedback-tasks', connection=app.redis)

    if not app.debug and not app.testing:
        if app.config['MAIL_SERVER']:
            auth = None
            if app.config['MAIL_USERNAME'] or app.config['MAIL_PASSWORD']:
                auth = (app.config['MAIL_USERNAME'],
                        app.config['MAIL_PASSWORD'])
            secure = None
            if app.config['MAIL_USE_TLS']:
                secure = ()
            mail_handler = SMTPHandler(
                mailhost=(app.config['MAIL_SERVER'], app.config['MAIL_PORT']),
                fromaddr='no-reply@' + app.config['MAIL_SERVER'],
                toaddrs=app.config['ADMINS'],
                subject='FeedBack App Failure',
                credentials=auth,
                secure=secure)
            mail_handler.setLevel(logging.ERROR)
            app.logger.addHandler(mail_handler)

        if app.config['LOG_TO_STDOUT']:
            stream_handler = logging.StreamHandler()
            stream_handler.setLevel(logging.INFO)
            app.logger.addHandler(stream_handler)
        else:
            if not os.path.exists('logs'):
                os.mkdir('logs')
            file_handler = RotatingFileHandler('logs/feedback.log',
                                               maxBytes=10240,
                                               backupCount=10)
            file_handler.setFormatter(
                logging.Formatter('%(asctime)s %(levelname)s: %(message)s '
                                  '[in %(pathname)s:%(lineno)d]'))
            file_handler.setLevel(logging.INFO)
            app.logger.addHandler(file_handler)

        app.logger.setLevel(logging.INFO)
        app.logger.info('Feedback is up!')

    # Start Modules!
    from . import modules

    modules.init_app(app)

    return app
Ejemplo n.º 6
0
def create_app(config):
    global app
    app = Flask(
        __name__,
        template_folder='../templates',
        static_folder='../static',
    )
    app.wsgi_app = ProxyFix(app.wsgi_app)
    app.config.update(config)

    app.url_rule_class = GeneratorRule

    app.redis = redis.Redis.from_url(config['REDISCLOUD_URL'])
    app.eventee = {
        'token': config['EVENTEE_TOKEN'],
        'email': config['EVENTEE_EMAIL'],
    }

    import views
    import login
    import login_oauth
    import talks
    import program
    import entrant
    import vote
    import filters
    import service
    import workshops
    import invoices

    from admin import admin

    app.register_blueprint(admin, url_prefix='/admin')
    return app
Ejemplo n.º 7
0
def create_app(config_file=None, settings_override=None):
    # Create and configure the app
    app = Flask(__name__, instance_relative_config=True)

    # Load the default config file
    app.config.from_pyfile(os.path.join(APP_ROOT, "config", "default.py"))

    if config_file:
        # Use the manually specified config file
        app.config.from_pyfile(config_file)
    else:
        # Use the default already loaded into the environment variable
        app.config.from_envvar(VAR_CONFIG_PATH)

    if settings_override:
        # Override config variables with the dictionary parm
        app.config.update(settings_override)

    # Ensure the instance folder exists
    try:
        os.makedirs(app.instance_path)
    except OSError:
        pass

    app.redis = Redis.from_url(app.config['REDIS_URL'])
    app.task_queue = Queue(os.getenv("RQ_NAME"), connection=app.redis)

    from . import index
    app.register_blueprint(index.bp)

    return app
Ejemplo n.º 8
0
def create_app(config):
    global app
    app = Flask(
        __name__,
        template_folder='../templates',
        static_folder='../static',
    )
    app.wsgi_app = ProxyFix(app.wsgi_app)
    app.config.update(config)

    app.url_rule_class = GeneratorRule

    app.redis = redis.Redis.from_url(config['REDISCLOUD_URL'])
    app.eventee = {
        'token': config['EVENTEE_TOKEN'],
        'email': config['EVENTEE_EMAIL'],
    }

    import views
    import login
    import login_oauth
    import talks
    import program
    import entrant
    import vote
    import filters
    import service
    import workshops
    import invoices
    return app
Ejemplo n.º 9
0
def create_app():
    app = Flask(__name__,
                template_folder='./templates',
                static_folder='./static')
    app.config.from_object(Config)
    app.redis = Redis.from_url(app.config['REDIS_URL'])
    app.task_queue = rq.Queue(connection=app.redis)
    migrate = Migrate(app, db)
    db.init_app(app)
    login_helper.init_app(app)

    with app.app_context():
        from .main.routes import bp as main_bp
        from .users.routes import bp as users_bp
        from .recipes.routes import bp as recipes_bp
        from .pantry.routes import bp as pantry_bp

        login_helper.login_view = 'users.login'
        db.create_all()

        app.register_blueprint(main_bp, url_prefix='/')
        app.register_blueprint(users_bp, url_prefix='/users')
        app.register_blueprint(recipes_bp, url_prefix='/recipes')
        app.register_blueprint(pantry_bp, url_prefix='/pantry')

    return app
Ejemplo n.º 10
0
def create_app():
    app = Flask(__name__)
    #print(os.path.dirname(__file__))
    app.config.from_object("web.defaultconfig")
    if "KFCHESS_CONFIG" in os.environ:
        app.config.from_envvar("KFCHESS_CONFIG")
        print("Using config at {}".format(os.environ["KFCHESS_CONFIG"]))
    else:
        print("KFCHESS_CONFIG envvar is not present, using default config")

    app.redis = redis.StrictRedis(host=app.config["REDIS_HOSTNAME"],
                                  port=app.config["REDIS_PORT"])

    socketio.init_app(app)
    login_manager.init_app(app)
    mysql.init_app(app)
    bcrypt.init_app(app)

    # this weird local import on create seems to be necessitated by flask-socketio's lack of support of blueprints
    from web.main import main, user
    app.register_blueprint(main, url_prefix='/')

    from web.game import game_bp, init_game
    app.register_blueprint(game_bp, url_prefix='/game')
    app.register_blueprint(game_bp, url_prefix='/games')
    init_game(app, socketio)

    return app
Ejemplo n.º 11
0
def create_app(config_class=Config):
    app = Flask(__name__)
    app.config.from_object(config_class)
    app.redis = Redis.from_url(app.config['REDIS_URL'])
    app.task_queue = rq.Queue('src-tasks', connection=app.redis, job_timeout="40m")
    # app.elasticsearch = Elasticsearch([app.config['ELASTICSEARCH_URL']]) \
    #     if app.config['ELASTICSEARCH_URL'] else None
    if not app.debug and not app.testing:
        # ...
        if app.config['LOG_TO_STDOUT']:
            stream_handler = logging.StreamHandler()
            stream_handler.setLevel(logging.INFO)
            app.logger.addHandler(stream_handler)
        else:
            if not os.path.exists('logs'):
                os.mkdir('logs')
            file_handler = RotatingFileHandler('logs/kumbayuni.log',
                                               maxBytes=10240, backupCount=10)
            file_handler.setFormatter(logging.Formatter(
                '%(asctime)s %(levelname)s: %(message)s '
                '[in %(pathname)s:%(lineno)d]'))
            file_handler.setLevel(logging.INFO)
            app.logger.addHandler(file_handler)

        app.logger.setLevel(logging.INFO)
        app.logger.info('Kumbayuni startup')
    return app
Ejemplo n.º 12
0
def create_app():

    app = Flask(__name__, static_url_path='')
    app.config.from_object(__name__)

    Swagger(app)

    app.redis = Redis.from_url(app.config['REDIS_URL'])
    app.task_queue = rq.Queue('tasks', connection=app.redis)

    @app.route('/')
    def index():
        return render_template('index.html', workspaces=base_obj._get_workspaces(), headings=headings)

    @app.route('/framework')
    def framework():
        r = requests.get('http://*****:*****@app.route('/search')
    def search():
        return render_template('search.html')

    from core.web.api import resources
    app.register_blueprint(resources)

    return app
Ejemplo n.º 13
0
def create_app(config_name=Config):
    app = Flask(__name__.split('.')[0])
    app.config.from_object(config_name)

    # Register before requests mixins prior to those that are inside extensions
    register_extensions(app)

    app.redis = redis.from_url(app.config['REDIS_URL'])

    app.task_queue = rq.Queue('freedomap-tasks', connection=app.redis)
    app.task_queue.empty()
    app.scheduler = rq_scheduler.Scheduler(
        queue=app.task_queue, connection=app.task_queue.connection)
    setup_tasks(app.scheduler)

    register_url_rules(app)
    register_blueprints(app)
    register_errorhandlers(app)
    app.shell_context_processor(
        lambda: {
            'db': db,
            'Protest': map_blueprint.models.Protest,
            'ProtestSubmission': map_blueprint.models.ProtestSubmission
        })

    return app
Ejemplo n.º 14
0
def create_app(config_name=Config):
    load_dotenv()
    app = Flask(__name__.split('.')[0])
    app.config.from_object(config_name)
    app.redis = redis.from_url(app.config['REDIS_URL'])
    app.config['SITEMAP_VIEW_DECORATORS'] = [load_page]

    # Don't cache js bundles if in development
    if app.config['ENV'] == 'development':
        app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 0
    # Register before requests mixins prior to those that are inside extensions
    register_extensions(app)
    register_url_rules(app)
    register_blueprints(app)
    register_errorhandlers(app)
    app.shell_context_processor(
        lambda: {
            'db': db,
            'User': main.models.User,
            'CourseColor': calendar.models.CourseColor,
            'CourseFilter': calendar.models.CourseFilter,
            'CourseIdentifier': calendar.models.CourseIdentifier
        })

    app.context_processor(inject_date)
    return app
Ejemplo n.º 15
0
def create_app(config_class=Config):
    app = Flask(__name__)
    app.config.from_object(config_class)

    app.redis = Redis.from_url(app.config['REDIS_URL'])
    app.task_queue = rq.Queue('beetroot_project-tasks', connection=app.redis)
    CORS(app, supports_credentials=True)
    db.init_app(app)
    migrate.init_app(app, db)

    mail.init_app(app)

    @jwt.unauthorized_loader
    def my_unauthorized_callback(error_msg):
        return jsonify({'msg': 'User Unauthorized'}), 401

    jwt.init_app(app)
    from app.main import main as main_bp
    app.register_blueprint(main_bp)

    from app.telebot import bp as telebot_bp
    app.register_blueprint(telebot_bp, url_prefix='/RDOALlvctMgPAwCCKDmMsb')

    if not app.debug and not app.testing:
        if app.config['MAIL_SERVER']:
            auth = None
            if app.config['MAIL_USERNAME'] or app.config['MAIL_PASSWORD']:
                auth = (app.config['MAIL_USERNAME'],
                        app.config['MAIL_PASSWORD'])
            secure = None
            if app.config['MAIL_USE_TLS']:
                secure = ()
            mail_handler = SMTPHandler(
                mailhost=(app.config['MAIL_SERVER'], app.config['MAIL_PORT']),
                fromaddr='no-reply@' + app.config['MAIL_SERVER'],
                toaddrs=app.config['MAIL_USERNAME'],
                subject='Beetroot project Failure',
                credentials=auth, secure=secure)
            mail_handler.setLevel(logging.ERROR)
            app.logger.addHandler(mail_handler)

        if app.config['LOG_TO_STDOUT']:
            stream_handler = logging.StreamHandler()
            stream_handler.setLevel(logging.INFO)
            app.logger.addHandler(stream_handler)
        else:
            if not os.path.exists('logs'):
                os.mkdir('logs')
            file_handler = RotatingFileHandler('logs/beetroot-project.log',
                                               maxBytes=10240, backupCount=10)
            file_handler.setFormatter(logging.Formatter(
                '%(asctime)s %(levelname)s: %(message)s '
                '[in %(pathname)s:%(lineno)d]'))
            file_handler.setLevel(logging.INFO)
            app.logger.addHandler(file_handler)

        app.logger.setLevel(logging.INFO)
        app.logger.info('Beetroot besvova490 startup')

    return app
Ejemplo n.º 16
0
def create_app(config_name='development'):
    app = Flask(__name__)
    setup = config_dic.get(config_name)

    if setup:
        app.config.from_object(setup)

    engine = create_engine(app.config['SQLALCHEMY_DATABASE_URI'],
                           convert_unicode=True)
    session_factory = sessionmaker(bind=engine,
                                   autocommit=False,
                                   autoflush=False)
    db_session = flask_scoped_session(session_factory)
    db_session.init_app(app)

    Base = declarative_base()
    Base.query = db_session.query_property()

    def do_setup():
        Base.metadata.create_all(bind=engine)

    do_setup()
    create_task_api(app)
    app.redis = Redis.from_url(app.config['REDIS_URL'])
    app.task_queue = rq.Queue('drweb-tasks', connection=app.redis)

    return {'app': app, 'db_session': db_session, 'Base': Base}
Ejemplo n.º 17
0
def create_app(config_class=Config):
    app = Flask(__name__)
    app.config.from_object(config_class)

    app.redis = Redis.from_url(app.config['REDIS_URL'])
    app.task_queue = rq.Queue('kura-tasks', connection=app.redis)

    app.elasticsearch = Elasticsearch([app.config['ELASTICSEARCH_URL']]) \
                        if app.config['ELASTICSEARCH_URL'] else None

    db.init_app(app)
    bcrypt.init_app(app)
    login_manager.init_app(app)
    mail.init_app(app)
    moment.init_app(app)
    migrate = Migrate(app, db)

    from src.main.routes import main
    from src.users.routes import users
    from src.tweets.routes import tweets
    from src.errors.handlers import errors

    app.register_blueprint(main)
    app.register_blueprint(users)
    app.register_blueprint(tweets)
    app.register_blueprint(errors)

    return app
Ejemplo n.º 18
0
def create_app(config=Config):
    app = Flask(__name__)
    app.config.from_object(config)

    db.init_app(app)
    migrate.init_app(app, db)
    login.init_app(app)
    mail.init_app(app)
    bootstrap.init_app(app)
    moment.init_app(app)
    babel.init_app(app)

    from app.errors import bp as errors_bp
    app.register_blueprint(errors_bp)

    from app.auth import bp as auth_bp
    app.register_blueprint(auth_bp, url_prefix='/auth')

    from app.main import bp as main_bp
    app.register_blueprint(main_bp)

    from app.api import bp as api_bp
    app.register_blueprint(api_bp, url_prefix='/api')

    app.elasticsearch = Elasticsearch([
        app.config['ELASTICSEARCH_URL']
    ]) if app.config['ELASTICSEARCH_URL'] else None

    app.redis = Redis.from_url(
        app.config['REDIS_URL']) if app.config['REDIS_URL'] else None
    app.task_queue = rq.Queue(
        'blog-tasks',
        connection=app.redis) if app.config['REDIS_URL'] else None

    return app
Ejemplo n.º 19
0
def create_app(config):
    global app
    app = Flask(
        __name__,
        template_folder='../templates',
        static_folder='../static',
    )
    app.wsgi_app = ProxyFix(app.wsgi_app)
    app.config.update(config)

    app.url_rule_class = GeneratorRule

    app.redis = redis.Redis.from_url(config['REDISCLOUD_URL'])
    app.eventee = {
        'token': config['EVENTEE_TOKEN'],
        'email': config['EVENTEE_EMAIL'],
    }

    from . import views
    from . import login
    from . import login_oauth
    from . import talks
    from . import program
    from . import entrant
    from . import vote
    from . import filters
    from . import service
    from . import workshops
    from . import invoices

    from .admin import admin

    app.register_blueprint(admin, url_prefix='/admin')
    return app
Ejemplo n.º 20
0
def create_app(config_name='development'):
    app = Flask(__name__)
    app.config.from_object(config[config_name])

    db.init_app(app)
    migrate.init_app(app, db)
    bcrypt.init_app(app)
    login_manager.init_app(app)

    if config_name != 'testing':
        app.redis = Redis.from_url(app.config['REDIS_URL'])
        app.task_queue = rq.Queue('webgame-tasks', connection=app.redis)
        app.task_queue.empty()
        app.task_queue.enqueue('app.tasks.gift_users.gift_users',
                               job_timeout=-1)

    from app.routes import base, shop, auth, google_auth, attack, profile, home
    from app.api import api_blueprint
    from app.models import user, army

    app.register_blueprint(home.home, url_prefix="")
    app.register_blueprint(base.base, url_prefix="/base")
    app.register_blueprint(shop.shop, url_prefix="/shop")
    app.register_blueprint(auth.auth, url_prefix="/auth")
    app.register_blueprint(attack.attack, url_prefix="/attack")
    app.register_blueprint(profile.profile, url_prefix="/profile")
    app.register_blueprint(google_auth.google_auth, url_prefix="/google")
    app.register_blueprint(api_blueprint, url_prefix='/api')

    return app
Ejemplo n.º 21
0
def create_app():
    app = Flask(__name__, static_folder='static', static_url_path='')
    app.config.from_object(config)

    cache.init_app(app, config={'CACHE_TYPE': 'simple'})

    db.init_app(app)
    migrate.init_app(app, db)
    ma.init_app(app)
    cors.init_app(app)
    jwt.init_app(app)

    with app.app_context():
        from . import routes, models, commands

        db.create_all()

        app.redis = Redis.from_url(app.config['REDIS_URL'])

        app.task_queue = rq.Queue(app.config['QUEUE'],
                                  connection=app.redis,
                                  default_timeout=-1)

        app.register_blueprint(api_bp, url_prefix='/api')

        os.makedirs(app.config['ISIRANK_FILES'], exist_ok=True)
        os.makedirs(app.config['IMAGE_FILES'], exist_ok=True)

        @app.route('/')
        def healthcheck():
            return "Application is running"

        return app
Ejemplo n.º 22
0
def create_app():
    app = Flask(__name__)
    app.config.from_object(Config)

    db.init_app(app)
    migrate.init_app(app, db)
    login.init_app(app)
    bootstrap.init_app(app)
    mail.init_app(app)

    from app.errors import bp as errors_bp
    app.register_blueprint(errors_bp)

    from app.auth import bp as auth_bp
    app.register_blueprint(auth_bp, url_prefix='/')

    from app.admin import bp as admin_bp
    app.register_blueprint(admin_bp, url_prefix='/admin')

    from app.teacher import bp as teacher_bp
    app.register_blueprint(teacher_bp, url_prefix='/teacher')

    from app.student import bp as student_bp
    app.register_blueprint(student_bp, url_prefix='/student')

    app.redis = Redis.from_url(app.config['REDIS_URL'])
    app.solution_queue = rq.Queue('pointer-solutions', connection=app.redis)
    app.email_queue = rq.Queue('pointer-emails', connection=app.redis)

    return app
Ejemplo n.º 23
0
def create_app(config_class=Config):
    app = Flask(__name__)
    app.config.from_object(config_class)

    db.init_app(app)
    migrate.init_app(app, db)
    login.init_app(app)
    mail.init_app(app)
    bootstrap.init_app(app)
    moment.init_app(app)
    babel.init_app(app)
    app.elasticsearch = (Elasticsearch([app.config["ELASTICSEARCH_URL"]])
                         if app.config["ELASTICSEARCH_URL"] else None)
    app.redis = Redis.from_url(app.config["REDIS_URL"])
    app.task_queue = rq.Queue("blog-tasks", connection=app.redis)

    from app.errors import bp as errors_bp  # noqa: E402
    from app.auth import bp as auth_bp  # noqa: E402
    from app.main import bp as main_bp  # noqa: E402
    from app.api import bp as api_bp  # noqa: E402

    app.register_blueprint(errors_bp)
    app.register_blueprint(auth_bp, url_prefix="/auth")
    app.register_blueprint(main_bp)
    app.register_blueprint(api_bp, url_prefix="/api")

    if not app.debug and not app.testing:
        if app.config["MAIL_SERVER"]:
            auth = None
            if app.config["MAIL_USERNAME"] or app.config["MAIL_PASSWORD"]:
                auth = (
                    app.config["MAIL_USERNAME"],
                    app.config["MAIL_PASSWORD"],
                )
            secure = None
            if app.config["MAIL_USE_TLS"]:
                secure = ()
            mail_handler = SMTPHandler(
                mailhost=(app.config["MAIL_SERVER"], app.config["MAIL_PORT"]),
                fromaddr="no-reply@" + app.config["MAIL_SERVER"],
                toaddrs=app.config["ADMINS"],
                subject="Blog Failure",
                credentials=auth,
                secure=secure,
            )
            mail_handler.setLevel(logging.ERROR)
            app.logger.addHandler(mail_handler)
        if not os.path.exists("logs"):
            os.mkdir("logs")
        file_handler = RotatingFileHandler("logs/blog.log",
                                           maxBytes=10240,
                                           backupCount=10)
        file_handler.setFormatter(
            logging.Formatter("%(asctime)s %(levelname)s: %(message)s "
                              "[in %(pathname)s:%(lineno)d]"))
        file_handler.setLevel(logging.INFO)
        app.logger.addHandler(file_handler)
        app.logger.setLevel(logging.INFO)
        app.logger.info("Blog startup")
    return app
Ejemplo n.º 24
0
def create_app():
    duchess = Flask(__name__, static_url_path='/static',
                    static_folder='assets')
    env = os.getenv('DUCHESS_ENV', 'Development')
    try:
        duchess.config.from_object('config.%s' % env)
    except ImportError:  # Assuming Heroku
        duchess.config.update(
            APP_DIR=os.path.abspath(os.path.dirname(__file__)),
            PROJECT_ROOT=os.path.abspath(
                os.path.join(os.path.dirname(__file__), os.pardir)
            ),
            SECRET_KEY=os.urandom(24),
            DEBUG=bool(os.getenv('DEBUG')),
            REDIS_URL=os.getenv('REDISCLOUD_URL'),
        )
    duchess.redis = Redis(duchess)

    if duchess.debug:
        from flask.ext.debugtoolbar import DebugToolbarExtension
        DebugToolbarExtension(duchess)

        autocompiler.watch_assets('duchess/assets')

    init_views(duchess)
    duchess.register_blueprint(api_router)

    return duchess
Ejemplo n.º 25
0
def create_app(config_class=Config):
    app = Flask(__name__)
    app.config.from_object(config_class)

    app.redis = Redis.from_url(app.config['REDIS_URL'])
    app.task_queue = rq.Queue('pi_task', connection=app.redis)

    cors.init_app(app)
    db.init_app(app)
    migrate.init_app(app, db)
    mail.init_app(app)

    from app.api.usuario import bp as usuario_bp
    app.register_blueprint(usuario_bp, url_prefix='/usuario')

    from app.api.login import bp as login_bp
    app.register_blueprint(login_bp, url_prefix='/login')

    from app.api.salas import bp as salas_bp
    app.register_blueprint(salas_bp, url_prefix='/salas')

    from app.api.tag import bp as tag_bp
    app.register_blueprint(tag_bp, url_prefix='/tag')

    from app.api.email import bp as email_bp
    app.register_blueprint(email_bp, url_prefix='/email')

    from app.api.agendamento import bp as agendamento_bp
    app.register_blueprint(agendamento_bp, url_prefix='/agendamento')

    return app
Ejemplo n.º 26
0
def init_app(config_name):
	"""项目的初始化功能"""
	app = Flask(__name__)

	# 终端脚本工具
	app.manager = Manager(app)

	# 启用数据迁移工具
	Migrate(app, db)
	# 添加数据迁移的命令到终端脚本工具中
	app.manager.add_command('db', MigrateCommand)

	# 设置配置类
	Config = config.get(config_name)

	# 加载配置类
	Config = config.get(config_name)

	# redis的链接初始化
	app.redis = get_redis_connection(Config.REDIS.get("default"))

	# 开启session功能
	Session(app)

	# 配置数据库连接
	db.init_app(app)

	# 启动日志
	setup_log(Config)

	return app
Ejemplo n.º 27
0
def create_app(debug=False, simulate=False):
    """Create an application context with blueprints."""
    app = Flask(__name__, static_folder='./resources')
    app.config['SECRET_KEY'] = 'iqR2cYJp93PuuO8VbK1Z'
    app.config['MONGO_DBNAME'] = 'cloud_cafe'
    app.config['BREWS_COLLECTION'] = 'brews'
    app.config['HISTORY_COLLECTION'] = 'history'
    app.config['INVENTORY_COLLECTION'] = 'inventory'
    app.config['PROFILE_COLLECTION'] = 'profiles'
    app.config['USERS_COLLECTION'] = 'accounts'
    app.config['SIMULATE_ROAST'] = simulate
    app.config['MONGO_URI'] = os.environ.get('MONGO_URI')
    app.config['REDIS_HOST'] = os.environ.get('REDIS_HOST')
    app.redis = Redis(host='redis')
    login_manager.init_app(app)
    mongo.init_app(app)
    sio.init_app(app)

    from .core import core as core_blueprint
    app.register_blueprint(core_blueprint)

    if simulate:
        ht.set_simulate(True)

    return app
Ejemplo n.º 28
0
def app():
    app = Flask(__name__)
    server = fakeredis.FakeServer()
    server.connected = True
    app.redis = fakeredis.FakeStrictRedis(server=server)
    app.app_context().push()
    yield app
Ejemplo n.º 29
0
def create_app():
    app = Flask(__name__)
    app.config.from_object(os.environ['APP_SETTINGS'])

    # Necessary to support signalling
    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True

    # allows visiting of say, /admin, not requiring the trailing
    # slash, which is the default. I.e., by default, /admin/ is
    # required which is annoying
    app.url_map.strict_slashes = False

    app.redis = Redis.from_url(app.config['REDIS_URL'])
    app.extract_queue = rq.Queue('extract', connection=app.redis)
    app.compare_queue = rq.Queue('compare', connection=app.redis)

    socketio.init_app(app,
                      cors_allowed_origins="*",
                      message_queue=app.config['REDIS_URL'])

    models.init_app(app)  # inits db
    admin.init_app(app)

    cors.init_app(app)  # TODO: Required on blueprints as well?

    routes.init_app(app)
    services.init_app(app)

    @app.shell_context_processor
    def ctx():
        return {"app": app, "db": models.db}

    return app
Ejemplo n.º 30
0
def create_app(config_class=Config):
    app = Flask(__name__, template_folder='templates')  #
    app.config.from_object(config_class)
    # commands
    # cli.register(microblog)
    # Initialize extensions
    initialize_extensions(app)

    # Register blueprints
    register_blueprints(app)
    app.elasticsearch = El([app.config['ELASTICSEARCH_URL']
                            ]) if app.config['ELASTICSEARCH_URL'] else None

    # logging

    if app.config.get('LOG_TO_STDOUT'):
        # from microblog.extensions import stream_handler
        app.logger.addHandler(stream_handler)
    else:
        # from microblog.extensions import file_handler
        app.logger.addHandler(file_handler)

    app.logger.setLevel(logging.INFO)
    app.logger.info("Microblog startup.")

    # Redis queue initialization
    app.redis = Redis.from_url(app.config['REDIS_URL'])
    app.task_queue = rq.Queue('microblog-tasks', connection=app.redis)

    return app
Ejemplo n.º 31
0
def create_app(config):
    global app
    app = Flask(
        __name__,
        template_folder='../templates',
        static_folder='../static'
    )
    app.wsgi_app = ProxyFix(app.wsgi_app)
    app.config.update(config)

    app.url_rule_class = GeneratorRule

    app.redis = redis.Redis.from_url(config['REDISCLOUD_URL'])

    import views
    import login
    import login_oauth
    import talks
    import program
    import entrant
    import vote
    import filters
    import presenters_go
    import service
    return app
Ejemplo n.º 32
0
def create_app(testing=False):
    if not testing:
        if not os.path.exists('logs'):
            os.makedirs('logs')
        fileConfig(os.path.abspath(os.path.dirname(__file__)) + '/logging.cfg')
    app = Flask(__name__)
    app.config.from_object(Config)
    Bootstrap(app)
    Session(app)
    FontAwesome(app)
    app.config["TESTING"] = testing
    app.register_blueprint(BP_HOMEPAGE)
    app.register_blueprint(BP_EXPLORER, url_prefix='/explorer')
    app.register_blueprint(BP_TABOO, url_prefix='/taboo')
    app.register_blueprint(BP_TASKS, url_prefix='/tasks')
    app.register_blueprint(BP_CODENAMES, url_prefix="/codenames")
    app.register_blueprint(BP_QUESTIONS, url_prefix="/questions")
    logger = create_logger(app)
    if testing:
        logger.setLevel(logging.DEBUG)
    DB.init_app(app)
    with app.app_context():
        create_all_db()
    app.redis = Redis.from_url(app.config['REDIS_URL'])
    app.task_queue = rq.Queue('quasimodo-tasks',
                              connection=app.redis,
                              default_timeout=50000)

    @app.before_request
    # pylint: disable=unused-variable
    def log_the_request():
        if not app.config["TESTING"]:
            logger.info("\t".join([get_ip(), request.url, str(request.data)]))

    return app
Ejemplo n.º 33
0
def create_app(configfile=None):
    app = Flask(__name__)

    app.config.from_object("app.config.Config")

    sentry_sdk.init(app.config["SENTRY_URL"], integrations=[FlaskIntegration()],
                    traces_sample_rate=app.config["SENTRY_RATE"])

    app.redis = redis.from_url(app.config['REDISTOGO_URL'])
    app.task_queue = rq.Queue(
        app.config['REDIS_QUEUES'], connection=app.redis, default_timeout=3600)
    # app.task_queue.failed_job_registry.requeue()
    app.scheduler = Scheduler(connection=app.redis, queue=app.task_queue)

    Bootstrap(app)

    from app.frontend import public_bp
    app.register_blueprint(public_bp)

    # app.config.from_object(rqmonitor.defaults)
    # app.config['RQ_MONITOR_REDIS_URL'] = app.config['REDISTOGO_URL']
    # app.register_blueprint(rqmonitor.monitor_blueprint, url_prefix="/rq")

    # app.config.from_object(rq_dashboard.default_settings)
    # app.config['RQ_DASHBOARD_REDIS_URL'] = app.config['REDISTOGO_URL']
    # app.register_blueprint(rq_dashboard.blueprint, url_prefix="/rqd")

    # app.config.from_object(rq_scheduler_dashboard.default_settings)
    # app.register_blueprint(
    #     rq_scheduler_dashboard.blueprint, url_prefix="/rqsd")

    return app
Ejemplo n.º 34
0
def create_app(config_class=Config):
    app = Flask(__name__)
    app.config.from_object(config_class)
    app.redis = Redis.from_url(app.config['REDIS_URL'])
    app.task_queue = rq.Queue('microblog-tasks', connection=app.redis)
    db.init_app(app)
    migrate.init_app(app, db)
    login.init_app(app)
    mail.init_app(app)
    bootstrap.init_app(app)
    moment.init_app(app)
    app.elasticsearch = Elasticsearch([app.config['ELASTICSEARCH_URL']]) \
    if app.config['ELASTICSEARCH_URL'] else None

    from app.api import bp as api_bp
    app.register_blueprint(api_bp, url_prefix='/api')

    from app.errors import bp as errors_bp
    app.register_blueprint(errors_bp)

    from app.auth import bp as auth_bp
    app.register_blueprint(auth_bp, url_prefix='/auth')

    from app.main import bp as main_bp
    app.register_blueprint(main_bp)

    if not app.debug and not app.testing:
        if app.config['MAIL_SERVER']:
            auth = None
            if app.config['MAIL_USERNAME'] or app.config['MAIL_PASSWORD']:
                auth = (app.config['MAIL_USERNAME'],
                        app.config['MAIL_PASSWORD'])
            secure = None
            if app.config['MAIL_USE_TLS']:
                secure = ()
            mail_handler = SMTPHandler(
                mailhost=(app.config['MAIL_SERVER'], app.config['MAIL_PORT']),
                fromaddr='no-reply@' + app.config['MAIL_SERVER'],
                toaddrs=app.config['ADMINS'],
                subject='Microblog Failure',
                credentials=auth,
                secure=secure)
            mail_handler.setLevel(logging.ERROR)
            app.logger.addHandler(mail_handler)

        if not os.path.exists('logs'):
            os.mkdir('logs')
        file_handler = RotatingFileHandler('logs/microblog.log',
                                           maxBytes=10240,
                                           backupCount=10)
        file_handler.setFormatter(
            logging.Formatter('%(asctime)s %(levelname)s: %(message)s '
                              '[in %(pathname)s:%(lineno)d]'))
        file_handler.setLevel(logging.INFO)
        app.logger.addHandler(file_handler)

        app.logger.setLevel(logging.INFO)
        app.logger.info('Microblog startup')

    return app
Ejemplo n.º 35
0
def create_app(app_name='web_app'):
    app = Flask(app_name)
    CORS(app)

    app.config['DEBUG'] = True
    app.register_blueprint(api)
    app.redis = redis.StrictRedis(host='localhost', port=6379, db=0)
    return app
Ejemplo n.º 36
0
def create_app(log_level="INFO", config="config.yml"):
    app = Flask(__name__)
    app.secret_key = 'test'
    app.config.from_object(__name__)

    config_vars = yaml.load(open(root + '/config.yml'))
    # inject all the yaml configs
    app.config.update(config_vars)
    db.init_app(app)
    Migrate(app, db)

    # Setup redis
    redis_config = app.config.get('redis_conn', dict(type='live'))
    typ = redis_config.pop('type')
    if typ == "mock_redis":
        from mockredis import mock_redis_client
        app.redis = mock_redis_client()
    else:
        app.redis = Redis(**redis_config)

    del app.logger.handlers[0]
    app.logger.setLevel(logging.NOTSET)
    log_format = logging.Formatter('%(asctime)s [%(name)s] [%(levelname)s]: %(message)s')
    log_level = getattr(logging, str(log_level), app.config.get('log_level', "INFO"))

    logger = logging.getLogger()
    logger.setLevel(log_level)
    handler = logging.StreamHandler(stream=sys.stdout)
    handler.setFormatter(log_format)
    logger.addHandler(handler)

    # Dynamically add all the filters in the filters.py file
    for name, func in inspect.getmembers(filters, inspect.isfunction):
        app.jinja_env.filters[name] = func

    app.rpc_connection = Proxy(
        "http://{0}:{1}@{2}:{3}/"
        .format(app.config['coinserv']['username'],
                app.config['coinserv']['password'],
                app.config['coinserv']['address'],
                app.config['coinserv']['port'])
        )

    from . import views
    app.register_blueprint(views.main)
    return app
Ejemplo n.º 37
0
def create_app():
    """Return an instance of the main Flask application."""
    app = Flask(package_name)

    # TODO: do some config
    app.redis = StrictRedis()

    from .error import register_error_handler, html_handler
    register_error_handler(app, html_handler)

    from .session import LazyRedisSessionInterface
    app.session_interface = LazyRedisSessionInterface()

    from .views import views
    app.register_blueprint(views)

    return app
Ejemplo n.º 38
0
def create_app(config):
    global app
    application = Flask(__name__)
    application.secret_key = "jednadvehonzajde"
    application.config.update(config)

    application.redis = redis.Redis()

    app = application

    import views
    import login
    import login_oauth
    import talks
    import filters

    return app
Ejemplo n.º 39
0
def create_app(setting, debug=False):

    app = Flask(__name__)
    app.config.from_object(setting)
    app.debug = debug
    app.redis = redis.StrictRedis(host=setting.REDIS_HOST, port=setting.REDIS_PORT, db=0)
    Cache.redis = app.redis
    # users routes
    user_view = UserHandler.as_view('user_api')
    app.add_url_rule(
        '/user/',
        view_func=user_view,
        methods=['POST']
    )
    app.add_url_rule(
        '/user/<string:name>',
        view_func=user_view,
        methods=['GET', 'PUT', 'DELETE']
    )
    # urls routes
    url_view = UrlHandler.as_view('url_api')
    app.add_url_rule(
        '/user/<string:name>/url',
        view_func=url_view,
        methods=['POST']
    )
    app.add_url_rule(
        '/user/<string:name>/url/<string:shortened>',
        view_func=url_view,
        methods=['GET', 'PUT', 'DELETE']
    )
    # redirect routes
    url_view = RedirectHandler.as_view('redirect_api')
    app.add_url_rule(
        '/<string:shortened>',
        view_func=url_view,
        methods=['GET']
    )

    db.init_app(app)
    return app
Ejemplo n.º 40
0
Archivo: nox.py Proyecto: cabin/nox.cx
def create_app():
    app = Flask(__name__)
    app.config.from_pyfile('settings.cfg')
    app.config.from_pyfile('local_settings.cfg', silent=True)

    app.redis = StrictRedis(db=app.config['REDIS_DB'])

    assets = Environment(app)
    assets.config['stylus_plugins'] = ['nib']
    assets.config['stylus_extra_args'] = ['--inline', '--include', 'static']
    assets.register(
        'css',
        '../styles/normalize.styl',
        '../styles/screen.styl',
        filters='stylus,cssmin', output='gen/screen.css')
    assets.register(
        'pinmeal',
        'vendor/jquery-1.8.2.js',
        'vendor/underscore.js',
        'vendor/backbone.js',
        'vendor/handlebars.runtime-1.0.rc.1.js',
        Bundle(
            '../scripts/spot*.handlebars',
            depends='dummy',  # to work around a webassets caching bug
            filters='handlebars', output='gen/pinmeal-handlebars.js'),
        Bundle(
            '../scripts/pinmeal.coffee',
            filters='coffeescript', output='gen/pinmeal-coffee.js'),
        filters='uglifyjs', output='gen/pinmeal.js')

    from main import main
    app.register_blueprint(main)
    #from pinmeal import pinmeal
    #app.register_blueprint(pinmeal, url_prefix='/pinmeal')

    return app
Ejemplo n.º 41
0
import os
import redis

from flask import Flask
from flask import request, redirect, render_template, url_for
from flask import Response

app = Flask(__name__)
app.redis = redis.StrictRedis(host='db', port=6379, db=0)

# Be super aggressive about saving for the development environment.
# This says save every second if there is at least 1 change.  If you use
# redis in production you'll want to read up on the redis persistence
# model.
app.redis.config_set('save', '1 1')

@app.route('/', methods=['GET', 'POST'])
def main_page():
    if request.method == 'POST':
        app.redis.lpush('entries', request.form['entry'])        
        return redirect(url_for('main_page'))
    else:
        entries = app.redis.lrange('entries', 0, -1)
        return render_template('main.html', entries=entries)

@app.route('/clear', methods=['POST'])
def clear_entries():
    app.redis.ltrim('entries', 1, 0)
    return redirect(url_for('main_page'))

if __name__ == "__main__":
Ejemplo n.º 42
0
def create_app(testing=False, live=False):
    from bhs_api.models import User, Role
    from bhs_api.forms import LoginForm

    app = Flask(__name__)
    app.testing = testing

    # load the config file
    conf = get_conf()
    app.conf = conf
    # Our config - need to move everything here
    app.config['VIDEO_BUCKET_URL'] = "https://storage.googleapis.com/bhs-movies"
    app.config['IMAGE_BUCKET_URL'] = "https://storage.googleapis.com/bhs-flat-pics"

    # Set app config
    app.config['DEBUG'] = True
    app.config['FRONTEND_SERVER'] = conf.frontend_server
    app.config['DEFAULT_NEXT'] = '/mjs'
    # Security Config
    app.config['SECRET_KEY'] = conf.secret_key
    app.config['WTF_CSRF_ENABLED'] = False
    app.config['SECURITY_PASSWORDLESS'] = True
    app.config['SECURITY_EMAIL_SENDER'] = 'BH Databases<*****@*****.**>'
    app.config['SECURITY_USER_IDENTITY_ATTRIBUTES'] = 'email'
    app.config['SECURITY_EMAIL_SUBJECT_PASSWORDLESS'] = 'Login link for Your Jewish Story'
    app.config['SECURITY_POST_LOGIN_VIEW'] = '/mjs'
    app.config['SECURITY_USER_IDENTITY_ATTRIBUTES'] = ('email', 'username', 'hash')
    # Mail Config
    app.config['MAIL_SERVER'] = conf.mail_server
    app.config['MAIL_PORT'] = conf.mail_port
    # Mail optional username and password
    try:
        app.config['MAIL_USERNAME'] = conf.mail_username
        app.config['MAIL_PASSWORD'] = conf.mail_password
    except AttributeError:
        pass

    # DB Config
    app.config['MONGODB_DB'] = conf.user_db_name
    app.config['MONGODB_HOST'] = conf.user_db_host
    app.config['MONGODB_PORT'] = conf.user_db_port
    # Redis
    app.config['REDIS_HOST'] = conf.redis_host
    app.config['REDIS_PORT'] = conf.redis_port
    app.config['REDIS_PASSWORD'] = getattr(conf, 'redis_password', None)

    # CACHING
    app.config['CACHING_TTL'] = conf.caching_ttl

    app.mail = Mail(app)
    app.db = MongoEngine(app)
    app.user_datastore = MongoEngineUserDatastore(app.db, User, Role)
    app.security = Security(app, app.user_datastore,
                            passwordless_login_form=LoginForm)
    # Create database connection object
    app.client_data_db = pymongo.MongoClient(conf.data_db_host, conf.data_db_port,
                    read_preference=pymongo.ReadPreference.SECONDARY_PREFERRED)
    app.data_db = app.client_data_db[conf.data_db_name]

    # Create the elasticsearch connection
    app.es = elasticsearch.Elasticsearch(conf.elasticsearch_host)
    app.es_data_db_index_name = getattr(conf, "elasticsearch_data_index", app.data_db.name)

    # Add the user's endpoints
    from bhs_api.user import user_endpoints
    app.register_blueprint(user_endpoints)
    # Add the v1 endpoint
    from bhs_api.v1_endpoints import v1_endpoints
    app.register_blueprint(v1_endpoints, url_prefix='/v1')
    # Initialize autodoc - https://github.com/acoomans/flask-autodoc
    #allow CORS
    cors = CORS(app, origins=['*'], headers=['content-type', 'accept',
                                            'authentication-token', 'Authorization'])
    # logging
    if live:
        app.config['PROPAGATE_EXCEPTIONS'] = True
        try:
            fh = logging.FileHandler(conf.log_file)
            formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
            fh.setFormatter(formatter)
            app.logger.addHandler(fh)
        except AttributeError:
            pass

    # redis
    try:
        app.redis = redis.StrictRedis(host=conf.redis_host,
                                      port=conf.redis_port,
                                      password = app.config['REDIS_PASSWORD'],
                                      db=0)
    except AttributeError:
        app.redis = None

    return app, conf
Ejemplo n.º 43
0
# -*- coding: utf-8 -*-
from flask import Flask, current_app, render_template
import redis
import time
import json


REDIS_HOST = '127.0.0.1'
REDIS_PORT = 6379

app = Flask(__name__)
app.debug = True
app.redis = None
app.ds = {
    'name': 'ds-articles-ok'
}

@app.before_first_request
def first():
    current_app.redis = redis.StrictRedis(host=REDIS_HOST,
                                          port=REDIS_PORT)

@app.route('/', methods=['GET'])
def welcome():
    now = int(time.time())
    items = current_app.redis.zrange(current_app.ds['name'], 0, now)

    return render_template('index.html', 
                           keys=[json.loads(item) for item in items])

if __name__ == '__main__':
Ejemplo n.º 44
0
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.login import LoginManager
from flask.ext.principal import Principal
from redis import Redis


app = Flask(__name__)
app.config.from_object('config')
db = SQLAlchemy(app)
login_manager = LoginManager()
login_manager.init_app(app)
principals = Principal(app)

# init redis and set as a app internal variable
app.redis = Redis(host=app.config.get('REDIS_HOST', None),
                  port=app.config.get('REDIS_PORT', None),
                  password=app.config.get('REDIS_PASS', None))

from saulify import views, models
Ejemplo n.º 45
0
def create_app(mode, configs=None, log_level=None, **kwargs):
    # Allow configuration information to be specified with enviroment vars
    env_configs = {}
    for key in os.environ:
        if key.startswith('SIMPLECOIN_CONFIG'):
            env_configs[key] = os.environ[key]

    env_configs = [env_configs[value] for value in sorted(env_configs)]

    configs = ['defaults.toml'] + (env_configs or []) + (configs or [])
    if len(configs) == 1:
        print("Unable to start with only the default config values! {}"
              .format(configs))
        exit(2)

    config_vars = {}
    for config in configs:
        if isinstance(config, basestring):
            if os.path.isabs(config):
                config_path = config
            else:
                config_path = os.path.join(root, config)
            config = open(config_path)

        updates = toml.loads(config.read())
        toml.toml_merge_dict(config_vars, updates)

    # Initialize our flask application
    # =======================================================================
    app = Flask(__name__, static_folder='../static', static_url_path='/static')
    app.jinja_loader = FileSystemLoader(os.path.join(root, 'templates'))

    # Objectizes all configurations
    # =======================================================================
    ConfigChecker(config_vars, app)

    # Setup logging
    # =======================================================================
    del app.logger.handlers[0]
    app.logger.setLevel(logging.NOTSET)
    log_format = logging.Formatter('%(asctime)s [%(name)s] [%(levelname)s]: %(message)s')
    log_level = getattr(logging, str(log_level), app.config['log_level'])

    logger = logging.getLogger()
    logger.setLevel(log_level)
    handler = logging.StreamHandler(stream=sys.stdout)
    handler.setFormatter(log_format)
    logger.addHandler(handler)

    # Handle optionally adding log file writers for each different run mode
    # =======================================================================
    if mode == "manage" and app.config['manage_log_file']:
        hdlr = logging.FileHandler(app.config['manage_log_file'])
        hdlr.setFormatter(log_format)
        logger.addHandler(hdlr)
    if mode == "scheduler" and app.config['scheduler_log_file']:
        hdlr = logging.FileHandler(app.config['scheduler_log_file'])
        hdlr.setFormatter(log_format)
        logger.addHandler(hdlr)
    if mode == "webserver" and app.config['webserver_log_file']:
        hdlr = logging.FileHandler(app.config['webserver_log_file'])
        hdlr.setFormatter(log_format)
        logger.addHandler(hdlr)

    logging.getLogger("gunicorn.access").setLevel(logging.WARN)
    logging.getLogger("requests.packages.urllib3.connectionpool").setLevel(logging.INFO)

    # Add the debug toolbar if we're in debug mode
    # =======================================================================
    if app.config['DEBUG'] and mode == "webserver":
        # Log all stdout and stderr when in debug mode for convenience
        class LoggerWriter:
            def __init__(self, logger, level):
                self.logger = logger
                self.level = level

            def write(self, message):
                if message != '\n':
                    self.logger.log(self.level, message)

        sys.stdout = LoggerWriter(app.logger, logging.DEBUG)
        sys.stderr = LoggerWriter(app.logger, logging.DEBUG)

    # Register the powerpool datastore + Cache
    # =======================================================================
    db.init_app(app)
    babel.init_app(app)
    app.config['BABEL_DEFAULT_LOCALE'] = app.config.get('default_locale')

    def configure_redis(config):
        typ = config.pop('type')
        if typ == "mock_redis":
            from mockredis import mock_redis_client
            return mock_redis_client()
        return Redis(**config)

    cache_config = app.config.get('main_cache', dict(type='live'))
    cache_redis = configure_redis(cache_config)

    ds_config = app.config.get('redis_conn', dict(type='live'))
    ds_redis = configure_redis(ds_config)

    # Take advantage of the fact that werkzeug lets the host kwargs be a Redis
    # compatible object
    cache.init_app(app, config=dict(CACHE_TYPE='redis', CACHE_REDIS_HOST=cache_redis))
    app.redis = ds_redis

    sentry = False
    if app.config.get('sentry'):
        try:
            from raven.contrib.flask import Sentry
            sentry = Sentry()
        except Exception:
            app.logger.error("Unable to initialize sentry!")

    # Helpful global vars
    # =======================================================================
    app.SATOSHI = Decimal('0.00000001')
    app.MAX_DECIMALS = 28

    # Configure app for running manage.py functions
    # =======================================================================
    if mode == "manage" or mode == "webserver":
        # Dynamically add all the filters in the filters.py file
        for name, func in inspect.getmembers(filters, inspect.isfunction):
            app.jinja_env.filters[name] = func

    if mode == "manage":
        # Initialize the migration settings
        Migrate(app, db)
        # Disable for management mode
        if sentry:
            sentry = False

    # Configure app for serving web content
    # =======================================================================
    elif mode == "webserver":
        # try and fetch the git version information
        try:
            output = subprocess.check_output("git show -s --format='%ci %h'",
                                             shell=True).strip().rsplit(" ", 1)
            app.config['hash'] = output[1]
            app.config['revdate'] = output[0]
        # celery won't work with this, so set some default
        except Exception:
            app.config['hash'] = ''
            app.config['revdate'] = ''

        app.logger.info("Starting up SimpleCoin!\n{}".format("=" * 100))

    # Configure app for running scheduler.py functions + instantiate scheduler
    # =======================================================================
    elif mode == "scheduler":
        if sentry and 'SENTRY_NAME' in app.config:
            app.config['SENTRY_NAME'] = app.config['SENTRY_NAME'] + "_scheduler"

        app.logger.info("=" * 80)
        app.logger.info("SimpleCoin cron scheduler starting up...")
        setproctitle.setproctitle("simplecoin_scheduler")

        sched = Scheduler(standalone=True)

        # monkey patch the scheduler to wrap each job call in its own flask
        # context. Kind of sloppy way to pass in the app context...
        Scheduler.app = app
        Scheduler._old_run_job = Scheduler._run_job

        def _run_job(self, *args, **kwargs):
            with self.app.app_context():
                Scheduler._old_run_job(self, *args, **kwargs)
        Scheduler._run_job = _run_job

        stage_tasks = set(["cache_profitability", "leaderboard",
                           "server_status", "update_network",
                           "cache_user_donation", "update_online_workers"])
        for task_config in app.config['tasks']:
            if not task_config.get('enabled', False):
                continue
            if app.config['stage'] and task_config['name'] not in stage_tasks:
                app.logger.debug(
                    "Skipping scheduling {} because in stage mode!"
                    .format(task_config['name']))
                continue

            stripped_config = task_config.copy()
            del stripped_config['enabled']
            task = getattr(sch, task_config['name'])
            sched.add_cron_job(task, **stripped_config)

        app.scheduler = sched

    if sentry:
        sentry.init_app(app, logging=True, level=logging.ERROR)

    # Route registration
    # =======================================================================
    from . import views, models, api, rpc_views
    app.register_blueprint(views.main)
    app.register_blueprint(rpc_views.rpc_views)
    app.register_blueprint(api.api, url_prefix='/api')

    return app
Ejemplo n.º 46
0
def create_instance():
    """
    Construct a new Flask instance and return it.
    """
    import os

    app = Flask(__name__)
    app.config.from_object('notifico.default_config')

    if app.config.get('NOTIFICO_ROUTE_STATIC'):
        # We should handle routing for static assets ourself (handy for
        # small and quick deployments).
        import os.path
        from werkzeug import SharedDataMiddleware

        app.wsgi_app = SharedDataMiddleware(app.wsgi_app, {
            '/': os.path.join(os.path.dirname(__file__), 'static')
        })

    if not app.debug:
        # If sentry (http://getsentry.com) is configured for
        # error collection we should use it.
        if app.config.get('SENTRY_DSN'):
            sentry.dsn = app.config.get('SENTRY_DSN')
            sentry.init_app(app)

    # Setup our redis connection (which is already thread safe)
    app.redis = Redis(
        host=app.config['REDIS_HOST'],
        port=app.config['REDIS_PORT'],
        db=app.config['REDIS_DB']
    )
    # Attach Flask-Cache to our application instance. We override
    # the backend configuration settings because we only want one
    # Redis instance.
    cache.init_app(app, config={
        'CACHE_TYPE': 'redis',
        'CACHE_REDIS_HOST': app.redis,
        'CACHE_OPTIONS': {
            'key_prefix': 'cache_'
        }
    })
    # Attach Flask-Mail to our application instance.
    mail.init_app(app)
    # Attach Flask-SQLAlchemy to our application instance.
    db.init_app(app)

    # Update celery's configuration with our application config.
    celery.config_from_object(app.config)

    # Import and register all of our blueprints.
    from notifico.views.account import account
    from notifico.views.public import public
    from notifico.views.projects import projects
    from notifico.views.pimport import pimport
    from notifico.views.admin import admin

    app.register_blueprint(account, url_prefix='/u')
    app.register_blueprint(projects)
    app.register_blueprint(public)
    app.register_blueprint(pimport, url_prefix='/i')
    app.register_blueprint(admin, url_prefix='/_')

    # Register our custom error handlers.
    from notifico.views import errors

    app.error_handler_spec[None][500] = errors.error_500

    # cia.vc XML-RPC kludge.
    from notifico.services.hooks.cia import handler
    handler.connect(app, '/RPC2')

    # Setup some custom Jinja2 filters.
    app.jinja_env.filters['pretty_date'] = pretty.pretty_date
    app.jinja_env.filters['plural'] = pretty.plural
    app.jinja_env.filters['fix_link'] = pretty.fix_link

    return app
Ejemplo n.º 47
0
# -*- coding: utf-8 -*-
import os
import redis

from flask import Flask
from flask import Response
from flask import json

app = Flask(__name__)
app.redis = redis.StrictRedis(host=os.getenv('WERCKER_REDIS_HOST', 'localhost'),
      port= 6379, db=0)

@app.route("/clouds.json")
def clouds():
  data = app.redis.lrange("clouds", 0, -1)
  resp = Response(json.dumps(data), status=200, mimetype='application/json')
  return resp

if __name__ == "__main__":
  port = int(os.getenv('PORT', 5000))
  app.run(host='0.0.0.0', port=port)
Ejemplo n.º 48
0
def create_app(mode, configs=None, log_level=None, **kwargs):
    # Allow configuration information to be specified with enviroment vars
    env_configs = {}
    for key in os.environ:
        if key.startswith('SIMPLECOIN_CONFIG'):
            env_configs[key] = os.environ[key]

    env_configs = [env_configs[value] for value in sorted(env_configs)]

    configs = ['defaults.toml'] + (env_configs or []) + (configs or [])
    if len(configs) == 1:
        print("Unable to start with only the default config values! {}"
              .format(configs))
        exit(2)

    config_vars = {}
    for config in configs:
        if isinstance(config, basestring):
            if os.path.isabs(config):
                config_path = config
            else:
                config_path = os.path.join(root, config)
            config = open(config_path)

        updates = toml.loads(config.read())
        toml.toml_merge_dict(config_vars, updates)

    # Initialize our flask application
    # =======================================================================
    app = Flask(__name__, static_folder='../static', static_url_path='/static')
    app.jinja_loader = FileSystemLoader(os.path.join(root, 'templates'))

    # Objectizes all configurations
    # =======================================================================
    ConfigChecker(config_vars, app)

    # Setup logging
    # =======================================================================
    del app.logger.handlers[0]
    app.logger.setLevel(logging.NOTSET)
    log_format = logging.Formatter('%(asctime)s [%(name)s] [%(levelname)s]: %(message)s')
    log_level = getattr(logging, str(log_level), app.config['log_level'])

    logger = logging.getLogger()
    logger.setLevel(log_level)
    handler = logging.StreamHandler(stream=sys.stdout)
    handler.setFormatter(log_format)
    logger.addHandler(handler)

    # Handle optionally adding log file writers for each different run mode
    # =======================================================================
    if mode == "manage" and app.config['manage_log_file']:
        hdlr = logging.FileHandler(app.config['manage_log_file'])
        hdlr.setFormatter(log_format)
        logger.addHandler(hdlr)
    if mode == "scheduler" and app.config['scheduler_log_file']:
        hdlr = logging.FileHandler(app.config['scheduler_log_file'])
        hdlr.setFormatter(log_format)
        logger.addHandler(hdlr)
    if mode == "webserver" and app.config['webserver_log_file']:
        hdlr = logging.FileHandler(app.config['webserver_log_file'])
        hdlr.setFormatter(log_format)
        logger.addHandler(hdlr)

    logging.getLogger("gunicorn.access").setLevel(logging.WARN)
    logging.getLogger("requests.packages.urllib3.connectionpool").setLevel(logging.INFO)

    # Add the debug toolbar if we're in debug mode
    # =======================================================================
    if app.config['DEBUG'] and mode == "webserver":
        # Log all stdout and stderr when in debug mode for convenience
        class LoggerWriter:
            def __init__(self, logger, level):
                self.logger = logger
                self.level = level

            def write(self, message):
                if message != '\n':
                    self.logger.log(self.level, message)

        sys.stdout = LoggerWriter(app.logger, logging.DEBUG)
        sys.stderr = LoggerWriter(app.logger, logging.DEBUG)

    # Register the powerpool datastore + Cache
    # =======================================================================
    db.init_app(app)

    def configure_redis(config):
        typ = config.pop('type')
        if typ == "mock_redis":
            from mockredis import mock_redis_client
            return mock_redis_client()
        return Redis(**config)

    cache_config = app.config.get('main_cache', dict(type='live'))
    cache_redis = configure_redis(cache_config)

    ds_config = app.config.get('redis_conn', dict(type='live'))
    ds_redis = configure_redis(ds_config)

    # Take advantage of the fact that werkzeug lets the host kwargs be a Redis
    # compatible object
    cache.init_app(app, config=dict(CACHE_TYPE='redis', CACHE_REDIS_HOST=cache_redis))
    app.redis = ds_redis

    sentry = False
    if app.config.get('sentry'):
        try:
            from raven.contrib.flask import Sentry
            sentry = Sentry()
        except Exception:
            app.logger.error("Unable to initialize sentry!")

    # Helpful global vars
    # =======================================================================
    app.SATOSHI = Decimal('0.00000001')
    app.MAX_DECIMALS = 28

    # Configure app for running manage.py functions
    # =======================================================================
    if mode == "manage" or mode == "webserver":
        # Dynamically add all the filters in the filters.py file
        for name, func in inspect.getmembers(filters, inspect.isfunction):
            app.jinja_env.filters[name] = func

    if mode == "manage":
        # Initialize the migration settings
        Migrate(app, db)
        # Disable for management mode
        if sentry:
            sentry = False

    # Configure app for serving web content
    # =======================================================================
    elif mode == "webserver":
        # try and fetch the git version information
        try:
            output = subprocess.check_output("git show -s --format='%ci %h'",
                                             shell=True).strip().rsplit(" ", 1)
            app.config['hash'] = output[1]
            app.config['revdate'] = output[0]
        # celery won't work with this, so set some default
        except Exception:
            app.config['hash'] = ''
            app.config['revdate'] = ''

        app.logger.info("Starting up SimpleCoin!\n{}".format("=" * 100))

    # Configure app for running scheduler.py functions + instantiate scheduler
    # =======================================================================
    elif mode == "scheduler":
        if sentry and 'SENTRY_NAME' in app.config:
            app.config['SENTRY_NAME'] = app.config['SENTRY_NAME'] + "_scheduler"

        app.logger.info("=" * 80)
        app.logger.info("SimpleCoin cron scheduler starting up...")
        setproctitle.setproctitle("simplecoin_scheduler")

        # Make app accessible from out monkey patched code. Messy....
        ThreadPool.app = app
        sched = Scheduler(standalone=True)
        # monkey patch the thread pool for flask contexts
        ThreadPool._old_run_jobs = ThreadPool._run_jobs
        def _run_jobs(self, core):
            self.app.logger.debug("Starting patched threadpool worker!")
            with self.app.app_context():
                ThreadPool._old_run_jobs(self, core)
        ThreadPool._run_jobs = _run_jobs
        # All these tasks actually change the database, and shouldn't
        # be run by the staging server
        if not app.config.get('stage', False):
            sched.add_cron_job(sch.compress_slices, minute='0,15,30,45',
                               second=35)
            # every minute at 55 seconds after the minute
            sched.add_cron_job(sch.generate_credits, second=55)
            sched.add_cron_job(sch.create_trade_req, args=("sell",), minute=1,
                               hour="0,6,12,18")
            sched.add_cron_job(sch.create_trade_req, args=("buy",), minute=1,
                               hour="0,6,12,18")
            # every minute at 55 seconds after the minute
            sched.add_cron_job(sch.collect_minutes, second=35)
            sched.add_cron_job(sch.collect_ppagent_data, second=40)
            # every five minutes 20 seconds after the minute
            sched.add_cron_job(sch.compress_minute,
                               minute='0,5,10,15,20,25,30,35,40,45,50,55',
                               second=20)
            # every hour 2.5 minutes after the hour
            sched.add_cron_job(sch.compress_five_minute, minute=2, second=30)
            # every minute 2 seconds after the minute
            sched.add_cron_job(sch.update_block_state, second=2)
            # every day
            sched.add_cron_job(sch.update_block_state, hour=0, second=0, minute=3)
        else:
            app.logger.info("Stage mode has been set in the configuration, not "
                            "running scheduled database altering cron tasks")

        sched.add_cron_job(sch.update_online_workers,
                           minute='0,5,10,15,20,25,30,35,40,45,50,55',
                           second=30)
        sched.add_cron_job(sch.cache_user_donation, minute='0,15,30,45',
                           second=15)
        sched.add_cron_job(sch.server_status, second=15)
        # every 15 minutes 2 seconds after the minute
        sched.add_cron_job(sch.leaderboard,
                           minute='0,5,10,15,20,25,30,35,40,45,50,55',
                           second=30)

        app.scheduler = sched

    if sentry:
        sentry.init_app(app, logging=True, level=logging.ERROR)

    # Route registration
    # =======================================================================
    from . import views, models, api, rpc_views
    app.register_blueprint(views.main)
    app.register_blueprint(rpc_views.rpc_views)
    app.register_blueprint(api.api, url_prefix='/api')

    return app
Ejemplo n.º 49
0
# 创建基于 Flask 的应用程序
app = Flask('tongbupan')

from werkzeug.contrib.fixers import ProxyFix
app.wsgi_app = ProxyFix(app.wsgi_app)

app.config.from_object(config)
app.debug = app.config.get('DEBUG', False)

app.secret_key = app.config['SECRET_KEY']
app.selnk_key = app.config["SELNK_KEY"]

assets = Assets(app)

from redis import Redis
app.redis = Redis(app.config['REDIS_HOST'], app.config['REDIS_PORT'], app.config['REDIS_DB'], app.config['REDIS_PASSWORD'])
app.session_interface = RedisSessionInterface(app.redis)

from lib.cache import init_cache
init_cache(app)

from flask.ext.pymongo import PyMongo
app.mongo = PyMongo(app, config_prefix='MONGO')

from lib.tokenstore import RedisTokenStore
RedisTokenStore.setup_store(app)

# 初始化进程全局的数据模型对象
models.setup(app)

Ejemplo n.º 50
0
from werkzeug import secure_filename
import flask
import utils
import json
from hanzi import Hanzi
from flask import current_app
import redis
import HanziMatcher
import sys

ALLOWED_EXTENSIONS = set(['txt', 'pdf', 'png', 'jpg', 'jpeg', 'gif'])

app = Flask(__name__)
app.config.from_pyfile('config.py')
print app.config
app.redis = redis.StrictRedis(host=app.config['REDIS_HOST'],port=app.config['REDIS_PORT'], db=0)

#print app.hanzi_list
#app.config['LABELED_DATASET_PATH'] = LABELED_DATASET_PATH

 #=  set(map(lambda x:x.decode('utf-8'), os.listdir(app.config['LABELED_DATASET_PATH']) ))
#app.hanzi_list = utils.read_handwriting(os.path.join("./","handwriting.txt"))

#if not app.debug:
#app.debug = True
import logging
from logging import FileHandler


file_handler = FileHandler(app.config['LOG_FILE_PATH'],encoding='utf-8')
#file_handler.setLevel(logging.ERROR)
Ejemplo n.º 51
0
    Redis will set up a connection pooler automatically, but the nano
    tier of Redis To Go only supports 10 concurrent connections.

    """
    pool = redis.ConnectionPool(host=app.config['REDIS_HOST'],
                                port=app.config['REDIS_PORT'],
                                password=app.config['REDIS_PASSWORD'],
                                db=db,
                                max_connections=max_connections)
    return redis.Redis(connection_pool=pool)


###
### Global Redis connection.
###
app.redis = redis_init()


###
### Hooks.
###


@app.before_request
def force_ssl():
    """Throw an error if the request is not secure."""
    criteria = [
        app.debug,
        request.is_secure,
        request.headers.get('X-Forwarded-Proto', "http") == "https",
    ]
Ejemplo n.º 52
0
from __future__ import print_function

import os
import sys
import redis

from flask import Flask
from flask import jsonify


app = Flask(__name__)
app.redis = redis.StrictRedis(host=os.getenv('REDIS_HOST', 'localhost'), socket_timeout=5)

@app.route('/set', methods=['POST'])
def set_value():
    try:
        app.redis.incr('total')
    except redis.ConnectionError as e:
        return jsonify({"status": "redis connection error"})
    else:
        return jsonify({"status": "ok"})

@app.route('/get')
def get_value():
    try:
        data = app.redis.get('total')
    except redis.ConnectionError as e:
        return jsonify({"status": "redis connection error"})
    else:
        return jsonify({"status": "ok", "data": int(data)})
Ejemplo n.º 53
0
from wtforms import widgets
import redis
import os



app = Flask(__name__)

app.config['SECRET_KEY'] = '123456790'
app.config['MONGODB_SETTINGS'] = {'DB': 'taobao',
                                  "HOST": 'localhost',
                                  "PORT": 27017}

app.__rootdir__ = os.getcwd()


# Create models
db = MongoEngine()
db.init_app(app)
#db.connection.admin.authenticate("root", "chenfuzhi")

app.conn = db.connection
app.redis = redis.Redis("localhost", 6379)

__all__ = ["app", "modes", "api", "views", "cqlui", "blacklist"]

from webadmin import *



Ejemplo n.º 54
0
def create_instance():
    """
    Construct a new Flask instance and return it.
    """
    import os

    app = Flask(__name__)
    app.config.from_object('notifico.default_config')

    if app.config.get('HANDLE_STATIC'):
        # We should handle routing for static assets ourself (handy for
        # small and quick deployments).
        import os.path
        from werkzeug import SharedDataMiddleware

        app.wsgi_app = SharedDataMiddleware(app.wsgi_app, {
            '/': os.path.join(os.path.dirname(__file__), 'static')
        })

    if not app.debug:
        # If sentry (http://getsentry.com) is configured for
        # error collection we should use it.
        if app.config.get('SENTRY_DSN'):
            sentry.dsn = app.config.get('SENTRY_DSN')
            sentry.init_app(app)

    # Setup our redis connection (which is already thread safe)
    app.redis = Redis(
        host=app.config['REDIS_HOST'],
        port=app.config['REDIS_PORT'],
        db=app.config['REDIS_DB']
    )
    cache.init_app(app, config={
        'CACHE_TYPE': 'redis',
        'CACHE_REDIS_HOST': app.redis,
        'CACHE_OPTIONS': {
            'key_prefix': 'cache_'
        }
    })
    db.init_app(app)

    with app.app_context():
        # Let SQLAlchemy create any missing tables.
        db.create_all()

    # Import and register all of our blueprints.
    from notifico.views.account import account
    from notifico.views.public import public
    from notifico.views.projects import projects
    from notifico.views.pimport import pimport
    from notifico.views.admin import admin

    app.register_blueprint(account, url_prefix='/u')
    app.register_blueprint(projects)
    app.register_blueprint(public)
    app.register_blueprint(pimport, url_prefix='/i')
    app.register_blueprint(admin, url_prefix='/_')

    # cia.vc XML-RPC kludge.
    from notifico.services.hooks.cia import handler
    handler.connect(app, '/RPC2')

    # Setup some custom Jinja2 filters.
    app.jinja_env.filters['pretty_date'] = pretty.pretty_date
    app.jinja_env.filters['plural'] = pretty.plural
    app.jinja_env.filters['fix_link'] = pretty.fix_link

    return app
Ejemplo n.º 55
0
from scrapy.utils.project import get_project_settings

from social_scraper.spiders.twitter import TwitterSpider
from social_scraper.spiders.fb import FacebookSpider

from social_scraper.settings import (API_HOST, API_PORT, API_DEBUG_MODE,
        CELERY_BROKER_URL, CELERY_IMPORTS, CELERY_RESULT_BACKEND,
        CELERYD_MAX_TASKS_PER_CHILD, REDIS_HOST, REDIS_PORT)


# flask app configuration
flask_app = Flask('profile_api')
api = restful.Api(flask_app)

# database setup
flask_app.redis = redis.StrictRedis(REDIS_HOST, port=REDIS_PORT, db=0)

# api output json encoding
output_json.func_globals['settings'] = {'ensure_ascii': False, 'encoding': 'utf8'}

# bind celery to flask app
flask_app.config.update(CELERY_BROKER_URL=CELERY_BROKER_URL,
    CELERY_RESULT_BACKEND=CELERY_RESULT_BACKEND,
    CELERYD_MAX_TASKS_PER_CHILD=CELERYD_MAX_TASKS_PER_CHILD,
    CELERY_IMPORTS=CELERY_IMPORTS,
)
celery = Celery(flask_app.import_name, broker=flask_app.config['CELERY_BROKER_URL'])
celery.conf.update(flask_app.config)

# Tasks
@celery.task(name='tasks.crawl')
import os
import redis

from flask import Flask
from flask import request, redirect, render_template, url_for
from flask import Response

app = Flask(__name__)
app.redis = redis.StrictRedis(host='127.0.0.1', port=6379, db=0)

# Be super aggressive about saving for the development environment.
# This says save every second if there is at least 1 change.  If you use
# redis in production you'll want to read up on the redis persistence
# model.
app.redis.config_set('save', '1 1')

@app.route('/', methods=['GET', 'POST'])
def main_page():
    if request.method == 'POST':
        app.redis.lpush('entries', request.form['entry'])        
        return redirect(url_for('main_page'))
    else:
        entries = app.redis.lrange('entries', 0, -1)
        return render_template('main.html', entries=entries)

@app.route('/clear', methods=['POST'])
def clear_entries():
    app.redis.ltrim('entries', 1, 0)
    return redirect(url_for('main_page'))

if __name__ == "__main__":
Ejemplo n.º 57
0
from flask import Flask
#from flask import Response
#from flask import json
import redis
app = Flask(__name__)
app.redis = redis.Redis(host='localhost',port=6379,db=0)
from app import views
Ejemplo n.º 58
0
# -*- coding: utf-8 -*-

import redis
from flask import Flask, g, render_template, current_app
from account.helpers import get_current_user
from account.views import bp_account
from trade.views import bp_trade
from fund.views import bp_fund
from api.views import bp_api
import database

app = Flask(__name__)
app.config.from_object('settings')

app.redis = redis.Redis(
        host=app.config['REDIS_HOST'],
        port=app.config['REDIS_PORT'],
        db=app.config['REDIS_NUM'])

app.db = database.Connection(
        host=app.config['MYSQL_HOST'], database=app.config['MYSQL_DATABASE'],
        user=app.config['MYSQL_USER'], password=app.config['MYSQL_PASSWORD'])

app.register_blueprint(bp_account, url_prefix="/account")
app.register_blueprint(bp_trade, url_prefix="/trade")
app.register_blueprint(bp_fund, url_prefix="/fund")
app.register_blueprint(bp_api, url_prefix="/api")


@app.before_request
def before_request():
    g.user = get_current_user()
Ejemplo n.º 59
0
Archivo: run.py Proyecto: lusac/coders
from room.views import room
from room.events import socketio

REDIS_HOST = os.getenv('REDIS_HOST', 'localhost')
REDIS_PORT = os.getenv('REDIS_PORT', 6379)
REDIS_PASS = os.getenv('REDIS_PASS', None)
REDIS_MASTER = os.getenv('REDIS_MASTER', None)

DEBUG = os.getenv('DEBUG', True)
PORT = int(os.getenv('PORT', '8000'))

app = Flask(__name__)

app.config['SECRET_KEY'] = '4403dac8-370a-4877-8d24-bab0511dc976'
app.config['SESSION_TYPE'] = 'redis'

app.register_blueprint(home)
app.register_blueprint(room)

if REDIS_HOST == 'localhost':
    app.redis = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT, db=0)
else:
    sentinel = Sentinel([(REDIS_HOST, REDIS_PORT)], socket_timeout=0.1, password=REDIS_PASS)
    app.redis = sentinel.master_for(REDIS_MASTER, socket_timeout=0.1)

app.debug = DEBUG

socketio.init_app(app)
if __name__ == '__main__':
    socketio.run(app, port=PORT, host='0.0.0.0')
Ejemplo n.º 60
0
    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')

from cchecker_web import cchecker_web
app.register_blueprint(cchecker_web, url_prefix='')

import redis
redis_pool = redis.ConnectionPool(host=app.config.get('REDIS_HOST'),
                                  port=app.config.get('REDIS_PORT'),
                                  db=app.config.get('REDIS_DB'))
app.redis = redis.Redis(connection_pool=redis_pool)
redis_connection = app.redis

# rq
from rq import Queue
app.queue = Queue('default', connection=app.redis)

@app.context_processor
def url_process():
    def url_root():
        return url_for('.show_root')
    return {'url_root': url_root}


from cchecker_web.utils import setup_uploads
setup_uploads(app)