import logging from flask import Flask, request from flask_cors import CORS from flask_redis import FlaskRedis import pika from config import Config logging.level = logging.DEBUG redis_hashmap_key = os.environ.get("REDIS_HASHMAP_KEY") rabbitmq_server = os.environ.get("RABBITMQ_SERVER") redis_store = FlaskRedis() pika_connection = pika.BlockingConnection(pika.ConnectionParameters(rabbitmq_server)) def create_app(): app = Flask(__name__) app.config.from_object(Config) CORS(app, resources={r"/*": {"origins": "*"}}) redis_store.init_app(app) return app def init_route(app):
import threading from six import text_type from flask import Flask from flask_redis import FlaskRedis from flask_ldapconn import LDAPConn app = Flask("lavatar") app.config.from_object("lavatar.default_settings") app.config.from_envvar("LAVATAR_SETTINGS", silent=True) if not app.debug: app.logger.addHandler(logging.StreamHandler()) app.logger.setLevel(logging.INFO) redis_store = FlaskRedis(app) ldap_conn = LDAPConn(app) class User(ldap_conn.Entry): base_dn = app.config["LDAP_USER_BASEDN"] object_class = app.config["LDAP_USER_OBJECTCLASS"] if isinstance(app.config["LDAP_USER_ATTR_MAIL"], str): app.config["LDAP_USER_ATTR_MAIL"] = [app.config["LDAP_USER_ATTR_MAIL"]] mail = ldap_conn.Attribute(app.config["LDAP_USER_ATTR_MAIL"][0]) for i, attr in enumerate(app.config["LDAP_USER_ATTR_MAIL"][1:]): exec("mail" + str(i) + "=ldap_conn.Attribute('" + attr + "')") photo = ldap_conn.Attribute(app.config["LDAP_USER_ATTR_PHOTO"]) # md5sum thread
from flask import Flask from flask_redis import FlaskRedis # Set global entities r = FlaskRedis() def create_app(): """Construct the core application.""" app = Flask(__name__, instance_relative_config=False) app.config.from_object('config.Config') with app.app_context(): # Initiate globals r.init_app(app, charset="utf-8", decode_responses=True) # Set global contexts r.set('medium_token', app.config['TOKEN']) r.set('medium_client_id', app.config['CLIENT_ID']) r.set('medium_client_secret', app.config['CLIENT_SECRET']) r.set('medium_publication', app.config['PUBLICATION']) r.set('medium_endpoint_me', app.config['ME_ENDPOINT']) # Import our modules from . import main return app
"""Simple Flask app connected to Redis""" import os from flask import Flask from flask_redis import FlaskRedis app = Flask(__name__) app.config[ 'REDIS_URL'] = f"redis://{os.getenv('REDIS_CONTAINER_NAME', 'redis')}:6379" redis = FlaskRedis(app) redis.set_response_callback('GET', int) def get_count(): """returns number of visitors as stored in Redis""" return redis.get('count') @app.route('/') def hello(): """ Root path: increments the visitor count returns welcome message along with visitor count """ redis.incr('count') count = get_count() s = 's' if count != 1 else '' return f"Welcome! {count} whale{s} have docked here."
from flask import Flask import jinja2 from requests import get from flask_redis import FlaskRedis app = Flask(__name__) redis_client = FlaskRedis(app) SITE_NAME = 'https://games.awdrgyjil1234.repl.co/' @app.route('/', defaults={'path': ''}) @app.route('/<path:path>') def proxy(path): resp = get(f'{SITE_NAME}{path}') if resp.headers.get('content-type'): return resp.content return resp.text if __name__ == '__main__': app.jinja_env.cache = {} app.run(host='0.0.0.0', port=8080)
class RedisClient: redis_store = FlaskRedis() active = False scripts = {} def init_app(self, app): self.active = app.config.get('REDIS_ENABLED') if self.active: self.redis_store.init_app(app) self.register_scripts() def register_scripts(self): # delete keys matching a pattern supplied as a parameter. Does so in batches of 5000 to prevent unpack from # exceeding lua's stack limit, and also to prevent errors if no keys match the pattern. # Inspired by https://gist.github.com/ddre54/0a4751676272e0da8186 self.scripts[ 'delete-keys-by-pattern'] = self.redis_store.register_script(""" local keys = redis.call('keys', ARGV[1]) local deleted = 0 for i=1, #keys, 5000 do deleted = deleted + redis.call('del', unpack(keys, i, math.min(i + 4999, #keys))) end return deleted """) def delete_cache_keys_by_pattern(self, pattern): r""" Deletes all keys matching a given pattern, and returns how many keys were deleted. Pattern is defined as in the KEYS command: https://redis.io/commands/keys * h?llo matches hello, hallo and hxllo * h*llo matches hllo and heeeello * h[ae]llo matches hello and hallo, but not hillo * h[^e]llo matches hallo, hbllo, ... but not hello * h[a-b]llo matches hallo and hbllo Use \ to escape special characters if you want to match them verbatim """ if self.active: return self.scripts['delete-keys-by-pattern'](args=[pattern]) return 0 def exceeded_rate_limit(self, cache_key, limit, interval, raise_exception=False): """ Rate limiting. - Uses Redis sorted sets - Also uses redis "multi" which is abstracted into pipeline() by FlaskRedis/PyRedis - Sends all commands to redis as a group to be executed atomically Method: (1) Add event, scored by timestamp (zadd). The score determines order in set. (2) Use zremrangebyscore to delete all set members with a score between - Earliest entry (lowest score == earliest timestamp) - represented as '-inf' and - Current timestamp minus the interval - Leaves only relevant entries in the set (those between now and now - interval) (3) Count the set (4) If count > limit fail request (5) Ensure we expire the set key to preserve space Notes: - Failed requests count. If over the limit and keep making requests you'll stay over the limit. - The actual value in the set is just the timestamp, the same as the score. We don't store any requets details. - return value of pipe.execute() is an array containing the outcome of each call. - result[2] == outcome of pipe.zcard() - If redis is inactive, or we get an exception, allow the request :param cache_key: :param limit: Number of requests permitted within interval :param interval: Interval we measure requests in :param raise_exception: Should throw exception :return: """ cache_key = prepare_value(cache_key) if self.active: try: pipe = self.redis_store.pipeline() when = time() pipe.zadd(cache_key, {when: when}) pipe.zremrangebyscore(cache_key, '-inf', when - interval) pipe.zcard(cache_key) pipe.expire(cache_key, interval) result = pipe.execute() return result[2] > limit except Exception as e: self.__handle_exception(e, raise_exception, 'rate-limit-pipeline', cache_key) return False else: return False def set(self, key, value, ex=None, px=None, nx=False, xx=False, raise_exception=False): key = prepare_value(key) value = prepare_value(value) if self.active: try: self.redis_store.set(key, value, ex, px, nx, xx) except Exception as e: self.__handle_exception(e, raise_exception, 'set', key) def incr(self, key, raise_exception=False): key = prepare_value(key) if self.active: try: return self.redis_store.incr(key) except Exception as e: self.__handle_exception(e, raise_exception, 'incr', key) def get(self, key, raise_exception=False): key = prepare_value(key) if self.active: try: return self.redis_store.get(key) except Exception as e: self.__handle_exception(e, raise_exception, 'get', key) return None def decrement_hash_value(self, key, value, raise_exception=False): return self.increment_hash_value(key, value, raise_exception, incr_by=-1) def increment_hash_value(self, key, value, raise_exception=False, incr_by=1): key = prepare_value(key) value = prepare_value(value) if self.active: try: return self.redis_store.hincrby(key, value, incr_by) except Exception as e: self.__handle_exception(e, raise_exception, 'increment_hash_value', key) def get_all_from_hash(self, key, raise_exception=False): key = prepare_value(key) if self.active: try: return self.redis_store.hgetall(key) except Exception as e: self.__handle_exception(e, raise_exception, 'get_all_from_hash', key) def set_hash_and_expire(self, key, values, expire_in_seconds, raise_exception=False): key = prepare_value(key) values = { prepare_value(k): prepare_value(v) for k, v in values.items() } if self.active: try: self.redis_store.hmset(key, values) return self.redis_store.expire(key, expire_in_seconds) except Exception as e: self.__handle_exception(e, raise_exception, 'set_hash_and_expire', key) def expire(self, key, expire_in_seconds, raise_exception=False): key = prepare_value(key) if self.active: try: self.redis_store.expire(key, expire_in_seconds) except Exception as e: self.__handle_exception(e, raise_exception, 'expire', key) def delete(self, *keys, raise_exception=False): keys = [prepare_value(k) for k in keys] if self.active: try: self.redis_store.delete(*keys) except Exception as e: self.__handle_exception(e, raise_exception, 'delete', ', '.join(keys)) def __handle_exception(self, e, raise_exception, operation, key_name): current_app.logger.exception('Redis error performing {} on {}'.format( operation, key_name)) if raise_exception: raise e
from flask_redis import FlaskRedis redis = FlaskRedis() def configure(app): #load all celery tasks redis.init_app(app)
def static_init_redis(): """静态方式初始化 redis""" for prefix in Config.REDIS_URL_PREFIX: redis_cache[prefix] = FlaskRedis(config_prefix=prefix)
def get_redis(app): return FlaskRedis(app)
""" Database and storage related functions and classes """ import datetime from enum import IntEnum import functools import sys from flask import g from flask_redis import FlaskRedis from peewee import IntegerField, DateTimeField, BooleanField, Proxy, Model, Database from peewee import CharField, ForeignKeyField, TextField, PrimaryKeyField from werkzeug.local import LocalProxy from .storage import file_url from .config import config rconn = FlaskRedis() dbp = Proxy() def get_db(): if "db" not in g: if dbp.is_closed(): dbp.connect() g.db = dbp return g.db db = LocalProxy(get_db) def db_init_app(app): dbconnect = dict(app.config["THROAT_CONFIG"].database)
from flask import Flask, render_template from flask_sqlalchemy import SQLAlchemy from flask_redis import FlaskRedis import pymysql import os app = Flask(__name__) app.config[ "SQLALCHEMY_DATABASE_URI"] = "mysql+pymysql://root:root@localhost:3306/movie" app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = True app.config["SECRET_KEY"] = 'af2fad8cfe1f4c5fac4aa5edf6fcc8f3' app.config["REDIS_URL"] = "redis://192.168.4.1:6379/0" app.config["UP_DIR"] = os.path.join(os.path.abspath(os.path.dirname(__file__)), "static/uploads/") app.config["FC_DIR"] = os.path.join(os.path.abspath(os.path.dirname(__file__)), "static/uploads/users/") app.debug = True db = SQLAlchemy(app) rd = FlaskRedis(app) from app.home import home as home_blueprint from app.admin import admin as admin_blueprint app.register_blueprint(home_blueprint) app.register_blueprint(admin_blueprint, url_prefix="/admin") @app.errorhandler(404) def page_not_found(error): return render_template("home/404.html"), 404
from flask_pymongo import PyMongo from flask_redis import FlaskRedis mongo = PyMongo() redis = FlaskRedis(decode_responses=True)
# from flask import Flask from flask_redis import FlaskRedis App = Flask(__name__) App.config.from_object('config') if 'REDIS_URL' in App.config: redis_client = FlaskRedis(App) try: redis_client.ping() except: redis_client = None from app import views