def from_url(url, db=None, **kwargs): """Returns an active Redis client generated from the given database URL. Will attempt to extract the database id from the path url fragment, if none is provided. """ return Redis.from_url(url, db, **kwargs)
def _get_current_redis_client() -> Redis: global _redis_clients client = _redis_clients.current_client if client is None: assert _connection_url is not None, "please set connection string first" client = _redis_clients.current_client = Redis.from_url( _connection_url) return client
def __init__(self, urls, **settings): """ Args: urls: list of connection urls for `redis.client.StrictRedis#from_url`. settings: additional settings for redis client. Attributes: mapping (dict): maintain the connection url & corresponding Redis client mapping. sharding: `tornext.sharding.Sharding` instance for dispatching requests. """ self.sharding = Sharding(urls) self.mapping = dict([(url, Redis.from_url(url)) for url in urls])
def create_redis_client(url, pool_size=10): """ Creates connection pool for running Redis commands. Parameters ---------- url : str A URL to connect to redis. pool_size : int Size of connection pool. Returns ------- client : redis.Redis A client to run redis command. """ return Redis.from_url(url, max_connections=pool_size)
def __init__(self, redis: Redis = None, url: str = None, host: str = '127.0.0.1', port: int = 6379, db: int = 0, password: str = None, logger_name: str = None): """ Instantiates a new Redis Config Store using one of three methods: 1. When a Redis instance is passed (using the parameter "redis"), it will simply reuse it 2. When a Redis URL is passed (using the parameter "url"), it will try to establish a connection using said URL 3. In all other cases, it will try to connect to a Redis instance with the provided data :param redis: Redis instance to use (default: None) :param url: Redis URL to connect to (default: None) :param host: Redis Host (default: 127.0.0.1) :param port: Redis Host Port (default: 6379) :param db: Redis Database (default: 0) :param password: Redis Host Password (default: None) :param logger_name: optional custom name provided in Log """ super().__init__(logger_name if logger_name else (url if url else ("Redis {}".format(host) if host else None))) # Setup instance vars self._redis: Redis = None if redis: # If Redis instance was provided, use it r = redis elif url: # If Redis URL was provided, create new instance with it r = Redis.from_url(url) else: # Else, try setting up a new Redis instance with primitive information r = RedisStore._build_redis(host, port, db, password) # Assign Redis instance to class self._redis = r
def from_url(url, db=None, master_for_args={}, **kwargs): """ Returns an active Redis client generated from the given database URL. Will attempt to extract the database id from the path url fragment, if none is provided. When url is starting with sentinels://, a sentinel object will be returned if no query parameter service_name in url, otherwise the master redis client will be returned. master_for_args will be applied to Sentinel.master_for. >>> import redis >>> redis.from_url('sentinels://node1:17700,node2:17700') Sentinel<sentinels=[node1:17700,node2:17700]> >>> redis.from_url( 'sentinels://node1:17700,node2:17700?service_name=mymaster', db=1) StrictRedis<SentinelConnectionPool<service=mymaster(master)> >>> redis.from_url( 'sentinels://node1:17700,node2:17700?service_name=mymaster&db=3', db=1) StrictRedis<SentinelConnectionPool<service=mymaster(master)> >>> redis.from_url( 'sentinels://node1:17700,node2:17700?service_name=mymaster', db=1, master_for_args={'redis_class':redis.Redis}) Redis<SentinelConnectionPool<service=mymaster(master)> """ parse_result = urlparse(url) if parse_result.scheme == 'sentinels': from sentinel import Sentinel sentinel, db_from_url, service_name = Sentinel.from_url(url, **kwargs) if not service_name: return sentinel else: return sentinel.master_for(service_name, db=(db_from_url or db or 0), **master_for_args) from redis.client import Redis return Redis.from_url(url, db, **kwargs)
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) from app.errors import bp as errors_blueprint app.register_blueprint(errors_blueprint) from app.auth import bp as auth_blueprint app.register_blueprint(auth_blueprint, url_prefix='/auth') from app.main import bp as main_blueprint app.register_blueprint(main_blueprint) 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']) app.task_queue = rq.Queue(app.config['MICROBLOG_QUEUE_NAME'], 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=f'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 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/microblog.log', maxBytes=10240, backupCount=10) file_handler.setLevel(logging.INFO) file_handler.setFormatter( logging.Formatter('%(asctime)s %(levelname)s: %(message)s ' '[in %(pathname)s:%(lineno)d]')) app.logger.addHandler(file_handler) app.logger.setLevel(logging.INFO) app.logger.info('Microblog startup') return app
if prefix_info: prefix = prefix_info['prefix'] else: prefix_info = { 'guild_id': guild_id, 'prefix': prefix } await bot.db.prefixes.insert_one(prefix_info) return commands.when_mentioned_or(prefix)(bot, message) bot = commands.Bot(command_prefix=get_prefix, activity=discord.Game('Default prefix: !?')) bot.launch_time = datetime.utcnow() for filename in os.listdir('./cogs'): if filename.endswith('.py'): bot.load_extension(f'cogs.{filename[:-3]}') with open('settings.json', 'r') as f: settings = json.load(f) token = settings['token'] bot.owner_id = settings['owner_id'] bot.leaderboards_api_url = settings['leaderboards_api_url'] motor_client = AsyncIOMotorClient(settings['mongo_uri']) bot.db = motor_client['coa'] player_cache = Redis.from_url(settings['redis_url'], db=0) max_page_cache = Redis.from_url(settings['redis_url'], db=1) bot.player_cache = player_cache bot.max_page_cache = max_page_cache bot.run(token)
def __init__(self, redis_url): self._client = Redis.from_url(redis_url, decode_responses=True)