Example #1
0
 def test_class_custom_init(self):
     app = self.create_app(REDIS_CLASS=CustomInitStrictRedis,
                           REDIS_URL='redis://127.0.0.1:6379/1')
     redis = Redis(app)
     redis.ping()
     self.assertEqual(redis.connection.foo, "bar")
     self.assertEqual(
         redis.connection.connection_pool.connection_kwargs['db'], '1')
 def test_class_custom_init(self):
     app = self.create_app(REDIS_CLASS=CustomInitStrictRedis,
                           REDIS_URL='redis://127.0.0.1:6379/1')
     redis = Redis(app)
     redis.ping()
     self.assertEqual(redis.connection.foo, "bar")
     self.assertEqual(
         redis.connection.connection_pool.connection_kwargs['db'], '1'
     )
Example #3
0
class FlaskRedisTestCase(unittest.TestCase):
    def setUp(self):
        """ Create a sample Flask Application """
        self.redis = Redis()
        self.app = flask.Flask('test-flask-redis')

    def test_init_app(self):
        """ Test the initation of our Redis extension """
        self.redis.init_app(self.app)
        assert self.redis.get('potato') is None
Example #4
0
def test_custom_prefix(app):
    """Test that config prefixes enable distinct connections."""
    app.config['REDIS_URL'] = 'redis://localhost:6379/1'
    redis_a = Redis(app)

    app.config['REDIS_URL'] = 'redis://localhost:6379/2'
    redis_b = Redis(app)

    assert redis_a.connection_pool.connection_kwargs['db'] == 1
    assert redis_b.connection_pool.connection_kwargs['db'] == 2
class FlaskRedisTestCase(unittest.TestCase):
    def setUp(self):
        """ Create a sample Flask Application """
        self.redis = Redis()
        self.app = flask.Flask(__name__)

    def test_init_app(self):
        """ Test the initation of our Redis extension """
        self.redis.init_app(self.app)
        assert self.redis.get("potato") is None

    def test_custom_prefix(self):
        """ Test the use of custom config prefixes """
        self.db1_redis = Redis(config_prefix="DB1")
        self.app.config["DB1_URL"] = "redis://localhost"
        self.app.config["DB1_DATABASE"] = 0
        self.db1_redis.init_app(self.app)

        self.db2_redis = Redis(config_prefix="DB2")
        self.app.config["DB2_URL"] = "redis://localhost"
        self.app.config["DB2_DATABASE"] = 1
        self.db2_redis.init_app(self.app)

        assert self.db1_redis.get("potato") is None
        assert self.db2_redis.get("potato") is None
Example #6
0
def test_custom_connection_class_using_string(app):
    """Test that Redis can be instructed to use a different Redis client
    using a class reference"""
    app.config['REDIS_CONNECTION_CLASS'] = 'redis.StrictRedis'

    redis = Redis()
    assert redis.client is None

    redis.init_app(app)
    assert redis.client is not None
    assert isinstance(redis.client, rd.StrictRedis)
class FlaskRedisTestCase(unittest.TestCase):

    def setUp(self):
        """ Create a sample Flask Application """
        self.redis = Redis()
        self.app = flask.Flask('test-flask-redis')

    def test_init_app(self):
        """ Test the initation of our Redis extension """
        self.redis.init_app(self.app)
        assert self.redis.get('potato') is None
    def test_custom_prefix(self):
        """ Test the use of custom config prefixes """
        self.db1_redis = Redis(config_prefix="DB1")
        self.app.config["DB1_URL"] = "redis://localhost"
        self.app.config["DB1_DATABASE"] = 0
        self.db1_redis.init_app(self.app)

        self.db2_redis = Redis(config_prefix="DB2")
        self.app.config["DB2_URL"] = "redis://localhost"
        self.app.config["DB2_DATABASE"] = 1
        self.db2_redis.init_app(self.app)

        assert self.db1_redis.get("potato") is None
        assert self.db2_redis.get("potato") is None
Example #9
0
def create_app(**options):
    r"""Factory function to create test application.

    :param \*\*options: Override default settings from given options.
    :type \*\*options: dict
    """
    # Initialize application and configure it from settings and given options
    app = Flask('testapp')
    app.config.from_object(settings)
    app.config.update(options)

    # Put necessary filter & globals to Jinja environment
    app.jinja_env.filters['format'] = format
    app.jinja_env.globals['constants'] = constants
    app.jinja_env.globals.update({
        'constants': constants,
        'float': float,
        'fromtimestamp': datetime.datetime.fromtimestamp,
        'iteritems': iteritems,
        'len': len,
    })

    # Register Redis databases
    Redis(app, 'REDIS_LINKS')
    Redis(app, 'REDIS_CONTENT')

    # Setup all available routes
    views = LazyViews(app, 'views')
    views.add('/', 'index', methods=('GET', 'POST'))
    views.add('/comments/<thread_uid>', 'comment', methods=('POST', ))
    views.add('/comments/<thread_uid>', 'comments')
    views.add('/quit', 'quit')
    views.add('/threads', 'start_thread', methods=('POST', ))
    views.add('/threads', 'threads')
    views.add('/threads/<thread_uid>/delete',
              'delete_thread',
              methods=('GET', 'POST'))
    views.add_error(400, 'error')
    views.add_error(403, 'error')
    views.add_error(404, 'error')
    views.add_error(Exception, 'error')

    # Put username from session to globals before each request
    @app.before_request
    def global_username():
        key = constants.USERNAME_KEY.format(app.config['KEY_PREFIX'])
        g.username = session.get(key) or ''

    return app
Example #10
0
    def test_init_app_behaviour(self):
        redis = Redis()
        self.assertRaises(AttributeError, getattr, redis, 'ping')

        app = self.create_app(REDIS_HOST=TEST_REDIS_HOST,
                              REDIS_PORT=TEST_REDIS_PORT,
                              REDIS_DB=TEST_REDIS_DB)

        redis.init_app(app)

        # Extensions initialized by init_app are not bound to any app
        # So you need an application context to access it
        self.assertRaises(RuntimeError, redis.ping)
        with get_context(app):
            redis.ping()
Example #11
0
def test_constructor(app):
    """Test that a constructor with app instance will initialize the
    connection.
    """
    redis = Redis(app)
    assert redis.client is not None
    assert hasattr(redis.client, 'connection_pool')
Example #12
0
def test_custom_connection_class_using_class(app):
    """Test that Redis can be instructed to use a different Redis client
    using a class reference"""
    class FakeProvider(object):
        @classmethod
        def from_url(cls, *args, **kwargs):
            return cls()

    app.config['REDIS_CONNECTION_CLASS'] = FakeProvider

    redis = Redis()
    assert redis.client is None

    redis.init_app(app)
    assert redis.client is not None
    assert isinstance(redis.client, FakeProvider)
Example #13
0
def test_init_app(app):
    """Test that a constructor without app instance will not initialize the
    connection.

    After Redis.init_app(app) is called, the connection will be initialized.
    """
    redis = Redis()
    assert redis.client is None

    redis.init_app(app)
    assert redis.client is not None
    assert hasattr(redis.client, 'connection_pool')

    if hasattr(app, 'extensions'):
        assert 'redis' in app.extensions
        assert app.extensions['redis'] == redis
Example #14
0
    def test_config_prefix(self):
        redis_url = TEST_REDIS_URL.replace('/0', '/1')
        app = self.create_app(REDIS_URL=TEST_REDIS_URL, REDIS1_URL=redis_url)

        redis = Redis(app)
        redis.ping()

        redis1 = Redis(app, 'REDIS1')
        redis1.ping()
Example #15
0
def test_constructor_app(mocker):
    """Test that the constructor passes the app to Redis.init_app"""
    mocker.patch.object(Redis, 'init_app', autospec=True)
    app_stub = mocker.stub(name='app_stub')

    Redis(app_stub)

    Redis.init_app.assert_called_once_with(mocker.ANY, app_stub)
def create_app(object_name):
    # config
    app.config.from_object(object_name)

    # app.config.update(
    #     DEBUG=True,
    #     SECRET_KEY='secret_xxx'
    # )
    # Redis Configs
    redis_instance = Redis()
    app.register_blueprint(login_app)
    app.register_blueprint(dashboard_app)
    app.register_blueprint(task_app)
    redis_instance.init_app(app)
    login_manager.init_app(app)

    return app
Example #17
0
 def setUp(self):
     self.redis = redis = Redis()
     self.app_a = self.create_app(REDIS_URL='redis://127.0.0.1:6379/0',
                                  REDIS_DECODE_RESPONSES=True)
     self.app_b = self.create_app(REDIS_URL='redis://127.0.0.1:6379/1',
                                  REDIS_DECODE_RESPONSES=True)
     redis.init_app(self.app_a)
     redis.init_app(self.app_b)
Example #18
0
    def test_default_class_redis_3(self):
        app = self.create_app(REDIS_URL=TEST_REDIS_URL)

        redis = Redis(app)
        real_redis = app.extensions['redis']['REDIS']

        self.assertIsInstance(
            real_redis,
            redis_py.Redis if flask_redis.IS_REDIS3 else StrictRedis)
Example #19
0
    def test_socket_path_in_host(self, host=None):
        host = host or '/var/lib/redis/run.sock'
        app = self.create_app(REDIS_HOST=host)

        redis = Redis(app)
        self.assertFalse(hasattr(redis, 'connection_pool'))

        real_redis = app.extensions['redis']['REDIS']
        self.assertEqual(real_redis.connection_pool.connection_class,
                         UnixDomainSocketConnection)
Example #20
0
def generate_context(config):
    """Create the Flask app context and initializes any extensions such as Celery, Redis, SQLAlchemy, etc.

    :param dict config: Partial Flask config dict from generate_config().

    :return: The Flask app instance.
    """
    flask_app = Flask(__name__)
    flask_app.config.update(config)
    flask_app.config['TESTING'] = True
    flask_app.config['CELERY_ACCEPT_CONTENT'] = ['pickle']

    if 'SQLALCHEMY_DATABASE_URI' in flask_app.config:
        db = SQLAlchemy(flask_app)
        db.engine.execute('DROP TABLE IF EXISTS celery_tasksetmeta;')
    elif 'REDIS_URL' in flask_app.config:
        redis = Redis(flask_app)
        redis.flushdb()

    Celery(flask_app)
    return flask_app
Example #21
0
def generate_context(config):
    """Create the Flask app context and initializes any extensions such as Celery, Redis, SQLAlchemy, etc.

    :param dict config: Partial Flask config dict from generate_config().

    :return: The Flask app instance.
    """
    flask_app = Flask(__name__)
    flask_app.config.update(config)
    flask_app.config['TESTING'] = True
    flask_app.config['CELERY_ACCEPT_CONTENT'] = ['pickle']

    if 'SQLALCHEMY_DATABASE_URI' in flask_app.config:
        db = SQLAlchemy(flask_app)
        db.engine.execute('DROP TABLE IF EXISTS celery_tasksetmeta;')
    elif 'REDIS_URL' in flask_app.config:
        redis = Redis(flask_app)
        redis.flushdb()

    Celery(flask_app)
    return flask_app
Example #22
0
class RedisClient():
    def __init__(self, channel=None):
        self.channel = channel or 'coati'
        self.redis_instance = Redis(current_app)
        self.pubsub = self.redis_instance.connection.pubsub()
        self.pubsub.subscribe(self.channel)

    def get(self, key):
        return self.redis_instance.get(key)

    def store(self, message_type, author_id):
        data = json.dumps({'type': message_type,
                           'user_id': author_id})
        self.redis_instance.connection.publish(self.channel, data)
    def test_custom_prefix(self):
        """ Test the use of custom config prefixes """
        self.db1_redis = Redis(config_prefix='DB1')
        self.app.config['DB1_URL'] = "redis://localhost:6379"
        self.app.config['DB1_DATABASE'] = 0
        self.db1_redis.init_app(self.app)

        self.db2_redis = Redis(config_prefix='DB2')
        self.app.config['DB2_URL'] = "redis://localhost:6379"
        self.app.config['DB2_DATABASE'] = 1
        self.db2_redis.init_app(self.app)

        self.db3_redis = Redis(config_prefix='DB3')
        self.app.config['DB3_URL'] = "redis://localhost:6379"
        self.db3_redis.init_app(self.app)

        self.db4_redis = Redis(config_prefix='DB4')
        self.app.config['DB4_URL'] = "redis://localhost:6379/5"
        self.db4_redis.init_app(self.app)

        assert self.db1_redis.get('potato') is None
        assert self.db2_redis.get('potato') is None
        assert self.db3_redis.get('potato') is None
        assert self.db4_redis.get('potato') is None
Example #24
0
    def test_config_prefix(self):
        redis_url = TEST_REDIS_URL.replace('/0', '/1')
        app = self.create_app(REDIS_URL=TEST_REDIS_URL,
                              REDIS1_URL=redis_url)

        redis = Redis(app)
        redis.ping()

        redis1 = Redis(app, 'REDIS1')
        redis1.ping()
Example #25
0
    def test_init_app_behaviour(self):
        redis = Redis()
        self.assertRaises(AttributeError, getattr, redis, 'ping')

        app = self.create_app(REDIS_HOST=TEST_REDIS_HOST,
                              REDIS_PORT=TEST_REDIS_PORT,
                              REDIS_DB=TEST_REDIS_DB)

        redis.init_app(app)
        redis.ping()
Example #26
0
    def test_init_app_behaviour(self):
        redis = Redis()
        self.assertRaises(AttributeError, getattr, redis, 'ping')

        app = self.create_app(REDIS_HOST=TEST_REDIS_HOST,
                              REDIS_PORT=TEST_REDIS_PORT,
                              REDIS_DB=TEST_REDIS_DB)

        redis.init_app(app)

        # Extensions initialized by init_app are not bound to any app
        # So you need an application context to access it
        self.assertRaises(RuntimeError, redis.ping)
        with get_context(app):
            redis.ping()
Example #27
0
def create_app():
    global app, redisdb, sqldb
    app = Flask(__name__)

    def generate_config_from_env():
        return {
            "sql": {
                "dbms": os.environ['SHORTIFY_SQL_DBMS'],
                "host": os.environ['SHORTIFY_SQL_HOST'],
                "port": os.environ['SHORTIFY_SQL_PORT'],
                "username": os.environ['SHORTIFY_SQL_USERNAME'],
                "password": os.environ['SHORTIFY_SQL_PASSWORD'],
                "database": os.environ['SHORTIFY_SQL_DATABASE']
            },
            "redis": {
                "host": os.environ['SHORTIFY_REDIS_HOST'],
                "port": os.environ['SHORTIFY_REDIS_PORT'],
                "db": os.environ['SHORTIFY_REDIS_DB'],
            }
        }

    config = generate_config_from_env()

    def configure_appinstance(app, config):
        sql = config['sql']
        redis = config['redis']
        app.config['SQLALCHEMY_DATABASE_URI'] = r'%s://%s:%s@%s:%s/%s' % (
            sql['dbms'], sql['username'], sql['password'], sql['host'],
            sql['port'], sql['database'])
        app.config['REDIS_HOST'] = redis['host']
        app.config['REDIS_PORT'] = redis['port']
        app.config['REDIS_DB'] = redis['db']

    configure_appinstance(app, config)
    sqldb = SQLAlchemy(app)
    redisdb = Redis(app)

    from app import models
    from app import views

    return app
Example #28
0
    def test_custom_prefix(self):
        """ Test the use of custom config prefixes """
        self.db1_redis = Redis(config_prefix='DB1')
        self.app.config['DB1_URL'] = "redis://localhost:6379"
        self.app.config['DB1_DATABASE'] = 0
        self.db1_redis.init_app(self.app)

        self.db2_redis = Redis(config_prefix='DB2')
        self.app.config['DB2_URL'] = "redis://localhost:6379"
        self.app.config['DB2_DATABASE'] = 1
        self.db2_redis.init_app(self.app)

        self.db3_redis = Redis(config_prefix='DB3')
        self.app.config['DB3_URL'] = "redis://localhost:6379"
        self.db3_redis.init_app(self.app)

        self.db4_redis = Redis(config_prefix='DB4')
        self.app.config['DB4_URL'] = "redis://localhost:6379/5"
        self.db4_redis.init_app(self.app)

        assert self.db1_redis.get('potato') is None
        assert self.db2_redis.get('potato') is None
        assert self.db3_redis.get('potato') is None
        assert self.db4_redis.get('potato') is None
Example #29
0
 def setUp(self):
     """ Create a sample Flask Application """
     self.redis = Redis()
     self.app = flask.Flask(__name__)
Example #30
0
app = Flask(__name__)
app.config['MONGODB_SETTINGS'] = {
    'db': 'flask-test',
    'host': 'ds027741.mongolab.com',
    'port': 27741,
    'username': '******',
    'password': '******'
}

app.config[
    'REDIS_URL'] = "redis://:[email protected]:17784/0"
app.config['SECRET_KEY'] = 'flask is cool'

db = MongoEngine(app)
redis_store = Redis(app)
bcrypt = Bcrypt(app)
api = Api(app)


class User(db.Document):
    # email = db.EmailField(unique=True)
    username = db.StringField(unique=True)
    password_hash = db.StringField()

    def hash_password(self, password):
        self.password_hash = bcrypt.generate_password_hash(password)

    def verify_password(self, password):
        return bcrypt.check_password_hash(self.password_hash, password)
 def setUp(self):
     """ Create a sample Flask Application """
     self.redis = Redis()
     self.app = flask.Flask(__name__)
Example #32
0
 def test_url(self):
     app = self.create_app(REDIS_URL='redis://127.0.0.1:6379/0')
     redis = Redis(app)
     redis.ping()
Example #33
0
from flask_restful import reqparse, abort, Api, Resource
import os
from flask_restful import Api
import pickle
import json
import yaml
import gzip
from datetime import timedelta

app = Flask(__name__)

api = Api(app)

app.config['REDIS_URL'] = 'redis://:redis123@localhost:6379/0'

r = Redis(app)
#
# r.set("msg:hello", "Hello Redis!!!")
#
# # step 5: Retrieve the hello message from Redis
# msg = r.get("msg:hello")

#uri = r.set("uri","https://devapi.appkeelaa.com/api/processpayments")
# dict_obj = {"name":"bhanu","last":"sheeram"}
# r.set("uri", str(dict_obj))

#
# @app.route('/api/postcall')


class Getcreateredis(Resource):
class FlaskRedisTestCase(unittest.TestCase):

    def setUp(self):
        """ Create a sample Flask Application """
        self.redis = Redis()
        self.app = flask.Flask(__name__)

    def test_init_app(self):
        """ Test the initation of our Redis extension """
        self.redis.init_app(self.app)
        assert self.redis.get('potato') is None

    def test_custom_prefix(self):
        """ Test the use of custom config prefixes """
        self.db1_redis = Redis(config_prefix='DB1')
        self.app.config['DB1_URL'] = "redis://localhost:6379"
        self.app.config['DB1_DATABASE'] = 0
        self.db1_redis.init_app(self.app)

        self.db2_redis = Redis(config_prefix='DB2')
        self.app.config['DB2_URL'] = "redis://localhost:6379"
        self.app.config['DB2_DATABASE'] = 1
        self.db2_redis.init_app(self.app)

        self.db3_redis = Redis(config_prefix='DB3')
        self.app.config['DB3_URL'] = "redis://localhost:6379"
        self.db3_redis.init_app(self.app)

        self.db4_redis = Redis(config_prefix='DB4')
        self.app.config['DB4_URL'] = "redis://localhost:6379/5"
        self.db4_redis.init_app(self.app)

        assert self.db1_redis.get('potato') is None
        assert self.db2_redis.get('potato') is None
        assert self.db3_redis.get('potato') is None
        assert self.db4_redis.get('potato') is None
Example #35
0
 def setUp(self):
     """ Create a sample Flask Application """
     self.redis = Redis()
     self.app = flask.Flask('test-flask-redis')
Example #36
0
import json
import stripe

import flask
from flask import g
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.login import LoginManager, current_user
from flask.ext.cdn import CDN
from flask_redis import Redis
from flask_limiter import Limiter
from flask_limiter.util import get_ipaddr
import settings
from helpers import ssl_redirect

DB = SQLAlchemy()
redis_store = Redis()
stripe.api_key = settings.STRIPE_SECRET_KEY
cdn = CDN()

import routes
from users.models import User


def configure_login(app):
    login_manager = LoginManager()
    login_manager.init_app(app)
    login_manager.login_view = 'register'

    @login_manager.user_loader
    def load_user(id):
        return User.query.get(int(id))
Example #37
0
 def test_class_from_string(self):
     app = self.create_app(REDIS_CLASS='redis.Redis',
                           REDIS_URL=TEST_REDIS_URL)
     redis = Redis(app)
     redis.ping()
Example #38
0
 def test_class(self):
     app = self.create_app(REDIS_CLASS=InheritFromStrictRedis,
                           REDIS_URL=TEST_REDIS_URL)
     redis = Redis(app)
     redis.ping()
Example #39
0
class FlaskRedisTestCase(unittest.TestCase):
    def setUp(self):
        """ Create a sample Flask Application """
        self.redis = Redis()
        self.app = flask.Flask(__name__)

    def test_init_app(self):
        """ Test the initation of our Redis extension """
        self.redis.init_app(self.app)
        assert self.redis.get('potato') is None

    def test_custom_prefix(self):
        """ Test the use of custom config prefixes """
        self.db1_redis = Redis(config_prefix='DB1')
        self.app.config['DB1_URL'] = "redis://localhost:6379"
        self.app.config['DB1_DATABASE'] = 0
        self.db1_redis.init_app(self.app)

        self.db2_redis = Redis(config_prefix='DB2')
        self.app.config['DB2_URL'] = "redis://localhost:6379"
        self.app.config['DB2_DATABASE'] = 1
        self.db2_redis.init_app(self.app)

        self.db3_redis = Redis(config_prefix='DB3')
        self.app.config['DB3_URL'] = "redis://localhost:6379"
        self.db3_redis.init_app(self.app)

        self.db4_redis = Redis(config_prefix='DB4')
        self.app.config['DB4_URL'] = "redis://localhost:6379/5"
        self.db4_redis.init_app(self.app)

        assert self.db1_redis.get('potato') is None
        assert self.db2_redis.get('potato') is None
        assert self.db3_redis.get('potato') is None
        assert self.db4_redis.get('potato') is None
Example #40
0
from flask import Flask, render_template
from flask_redis import Redis
import json, pickle
import time

app = Flask(__name__)
app.config['REDIS_HOST'] = '35.170.1.59'
app.config['REDIS_PORT'] = 6379
redis = Redis(app)


@app.route('/', methods=['GET'])
def homepage():
    return render_template('home.html', lines=enumerate(fill_table(), 1))


def fill_table():
    lines = []
    for line in redis.zrange('tweets', 0, 9):
        # line = line.strip('[]')
        one_row = list(line.split(","))
        tag = one_row[0]
        pos = one_row[1]
        neg = one_row[2]
        neu = one_row[3]
        row = [tag[3:-1], pos, neg, neu[:-1]]
        # one_row = one_row[0].strip('[\'')
        # one_row = one_row[3].strip(']')
        # lines.append(one_row)
        lines.append(row)
    return lines
Example #41
0
 def test_non_string_port(self):
     app = self.create_app(REDIS_HOST=TEST_REDIS_HOST,
                           REDIS_PORT=str(TEST_REDIS_PORT),
                           REDIS_DB=str(TEST_REDIS_DB))
     redis = Redis(app)
     redis.ping()
Example #42
0
def make_auctions_app(global_conf,
                      redis_url='redis://localhost:7777/0',
                      external_couch_url='http://localhost:5000/auction',
                      internal_couch_url='http://localhost:9000/',
                      proxy_internal_couch_url='http://localhost:9000/',
                      auctions_db='auctions',
                      hash_secret_key='',
                      timezone='Europe/Kiev',
                      preferred_url_scheme='http',
                      debug=False,
                      auto_build=False,
                      event_source_connection_limit=1000):
    """
    [app:main]
    use = egg:openprocurement.auction#auctions_server
    redis_url = redis://:passwod@localhost:1111/0
    external_couch_url = http://localhost:1111/auction
    internal_couch_url = http://localhost:9011/
    auctions_db = auction
    timezone = Europe/Kiev
    """
    auctions_server.proxy_connection_pool = ConnectionPool(factory=Connection,
                                                           max_size=20,
                                                           backend="gevent")
    auctions_server.proxy_mappings = Memoizer({})
    auctions_server.event_sources_pool = deque([])
    auctions_server.config['PREFERRED_URL_SCHEME'] = preferred_url_scheme
    auctions_server.config['REDIS_URL'] = redis_url
    auctions_server.config['event_source_connection_limit'] = int(
        event_source_connection_limit)
    auctions_server.config['EXT_COUCH_DB'] = urljoin(external_couch_url,
                                                     auctions_db)
    auctions_server.add_url_rule('/' + auctions_db + '/<path:path>',
                                 'couch_server_proxy',
                                 couch_server_proxy,
                                 methods=['GET'])
    auctions_server.add_url_rule('/' + auctions_db + '/',
                                 'couch_server_proxy',
                                 couch_server_proxy,
                                 methods=['GET'],
                                 defaults={'path': ''})

    auctions_server.add_url_rule('/' + auctions_db + '_secured/<path:path>',
                                 'auth_couch_server_proxy',
                                 auth_couch_server_proxy,
                                 methods=['GET'])
    auctions_server.add_url_rule('/' + auctions_db + '_secured/',
                                 'auth_couch_server_proxy',
                                 auth_couch_server_proxy,
                                 methods=['GET'],
                                 defaults={'path': ''})

    auctions_server.config['INT_COUCH_URL'] = internal_couch_url
    auctions_server.config['PROXY_COUCH_URL'] = proxy_internal_couch_url
    auctions_server.config['COUCH_DB'] = auctions_db
    auctions_server.config['TIMEZONE'] = tz(timezone)
    auctions_server.redis = Redis(auctions_server)
    auctions_server.couch_server = Server(
        auctions_server.config.get('INT_COUCH_URL'),
        session=Session(retry_delays=range(10)))
    if auctions_server.config['COUCH_DB'] not in auctions_server.couch_server:
        auctions_server.couch_server.create(auctions_server.config['COUCH_DB'])

    auctions_server.db = auctions_server.couch_server[
        auctions_server.config['COUCH_DB']]
    auctions_server.config['HASH_SECRET_KEY'] = hash_secret_key
    sync_design(auctions_server.db)
    auctions_server.config['ASSETS_DEBUG'] = True if debug else False
    assets.auto_build = True if auto_build else False
    return auctions_server
Example #43
0
 def test_default_behaviour(self):
     app = self.create_app(REDIS_HOST=TEST_REDIS_HOST,
                           REDIS_PORT=TEST_REDIS_PORT,
                           REDIS_DB=TEST_REDIS_DB)
     redis = Redis(app)
     redis.ping()
Example #44
0
# App Config
app = Flask(__name__)
socketio = SocketIO(app, async_mode=async_mode)
app.config.from_object(app_config[FLASK_CONFIG])
app.config.from_pyfile('config.py')
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
app.config['SQLALCHEMY_ECHO'] = False
app.config['SQLALCHEMY_POOL_SIZE'] = 100
app.config['CDN_DOMAIN'] = 'd30bzjua38r0w8.cloudfront.net'
app.config['CDN_HTTPS'] = True
app.config['CDN_DEBUG'] = True

# DB Config
db.init_app(app)
redis = Redis()
redis.init_app(app)

# Migration Config
migration = Migrate(app, db)

# Session Config
app.secret_key = THE_SECRET_KEY
app.config['SESSION_TYPE'] = 'filesystem'
Session(app)

# CDN Config
cdn.init_app(app)

# flask-compress config
compress.init_app(app)
# !/usr/local/python/bin/python
# -*- coding: utf-8 -*-
# (C) Wu Dong, 2020
# All rights reserved
# @Author: 'Wu Dong <*****@*****.**>'
# @Time: '2020-06-28 17:00'

from flask import Flask
from flask_redis import Redis, K_RDS_DEFAULT_BIND

redis = Redis()
app = Flask(__name__)

app.config[K_RDS_DEFAULT_BIND] = "default"
app.config["REDIS_BINDS"] = {
    "default": {
        "REDIS_PREFIX": "DEFAULT:",
        "REDIS_URL": "redis://:[email protected]:16379/12",
    },
    "DB12": {
        "REDIS_PREFIX": "EG12:",
        "REDIS_URL": "redis://:[email protected]:16379/12",
    },
    "DB13": {
        "REDIS_PREFIX": "EG13:",
        "REDIS_URL": "redis://:[email protected]:16379/13",
    }
}
redis.init_app(app)

if __name__ == "__main__":
Example #46
0
from flask_redis import Redis
from flask_sqlalchemy import SQLAlchemy

# Create database connection object
db = SQLAlchemy()

# Create Redis connection object
redis = Redis()
Example #47
0
# monkey patching is necessary because this application uses a background
# thread
if async_mode == 'eventlet':
    import eventlet
    eventlet.monkey_patch()
elif async_mode == 'gevent':
    from gevent import monkey
    monkey.patch_all()


app = Flask(__name__)
login_manager = LoginManager()
db = SQLAlchemy()
socketio = SocketIO()
oauth = OAuth(app)
redis = Redis()
moment = Moment()

with app.app_context():

    config_name = os.getenv('FLASK_CONFIG') or 'development'
    app.config.from_object(config[config_name])
    config[config_name].init_app(app)

    db.app = app
    db.init_app(app)

    login_manager.init_app(app)
    login_manager.session_protection = 'strong'
    login_manager.login_view = 'login'
    login_manager.login_message = u'请先登陆系统,若遗忘密码,请联系管理员'