Python StrictRedis.from_url方法代码示例

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import from_url [as 别名]
def render_task(dburl, docpath, slug):
    """Render a document."""
    oldcwd = os.getcwd()
    try:
        os.chdir(os.path.join(docpath, slug))
    except:
        db = StrictRedis.from_url(dburl)
        job = get_current_job(db)
        job.meta.update({'out': 'Document not found.', 'return': 127, 'status': False})
        return 127

    db = StrictRedis.from_url(dburl)
    job = get_current_job(db)
    job.meta.update({'out': '', 'milestone': 0, 'total': 1, 'return': None,
                     'status': None})
    job.save()

    p = subprocess.Popen(('lualatex', '--halt-on-error', slug + '.tex'),
                         stdout=subprocess.PIPE)

    out = []

    while p.poll() is None:
        nl = p.stdout.readline()
        out.append(nl)
        job.meta.update({'out': ''.join(out), 'return': None,
                         'status': None})
        job.save()

    out = ''.join(out)
    job.meta.update({'out': ''.join(out), 'return': p.returncode, 'status':
                     p.returncode == 0})
    job.save()
    os.chdir(oldcwd)
    return p.returncode

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import from_url [as 别名]
    def __init__(self, old_redis_url, new_redis_url, dry_run=True,
                 per_recording_list=False, s3_import=False, s3_root=None):
        self.old_redis = StrictRedis.from_url(old_redis_url, decode_responses=True)
        self.dry_run = dry_run
        self.per_recording_list = per_recording_list
        self.s3_import = s3_import

        if s3_import:
            assert(s3_root)
            import boto3
            self.s3_root = s3_root
            self.s3 = boto3.client('s3')
        else:
            self.s3_root = None
            self.s3 = None

        if self.dry_run:
            import redis
            redis.StrictRedis = fakeredis.FakeStrictRedis
            self.redis = FakeStrictRedis.from_url(new_redis_url, decode_responses=True)
        else:
            self.redis = StrictRedis.from_url(new_redis_url, decode_responses=True)

        print('Redis Inited')

        self.cli = CLIUserManager(new_redis_url)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import from_url [as 别名]
def init_redis(config):
    """ Init redis from config, with fallback to localhost
    """
    try:
        rc = StrictRedis.from_url(config['redis_url'])
        rc.ping()
    except:
        rc = StrictRedis.from_url('redis://localhost/')
        rc.ping()

    return rc

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import from_url [as 别名]
def continuous_migration(skip_files=None):
    """Task to continuously migrate what is pushed up by Legacy."""
    if skip_files is None:
        skip_files = current_app.config.get(
            'RECORDS_MIGRATION_SKIP_FILES',
            False,
        )
    redis_url = current_app.config.get('CACHE_REDIS_URL')
    r = StrictRedis.from_url(redis_url)
    lock = Lock(r, 'continuous_migration', expire=120, auto_renewal=True)
    if lock.acquire(blocking=False):
        try:
            while r.llen('legacy_records'):
                raw_record = r.lrange('legacy_records', 0, 0)
                if raw_record:
                    migrate_and_insert_record(
                        zlib.decompress(raw_record[0]),
                        skip_files=skip_files,
                    )
                    db.session.commit()
                r.lpop('legacy_records')
        finally:
            lock.release()
    else:
        LOGGER.info("Continuous_migration already executed. Skipping.")

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import from_url [as 别名]
def redis(redis_dsn):
    if redis_dsn:
        r = StrictRedis.from_url(redis_dsn)
    else:
        r = FakeRedis()
    r.flushdb()
    return r

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import from_url [as 别名]
def decrement(bot, term):
    redis = StrictRedis.from_url(bot.config['System']['redis_url'])
    if redis.hexists(bot.config['System']['redis_prefix'] + "karma", term):
        oldvalue = int(redis.hget(bot.config['System']['redis_prefix'] + "karma", term))
        redis.hset(bot.config['System']['redis_prefix'] + "karma", term, oldvalue - 1)
    else:
        redis.hset(bot.config['System']['redis_prefix'] + "karma", term, -1)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import from_url [as 别名]
def init(configfile='config.yaml', redis_url=None):
    logging.basicConfig(format='%(asctime)s: [%(levelname)s]: %(message)s',
                        level=logging.DEBUG)
    logging.debug('')

    # set boto log to error
    boto_log = logging.getLogger('boto')
    if boto_log:
        boto_log.setLevel(logging.ERROR)

    config = load_yaml_config(configfile)

    if not redis_url:
        redis_url = expandvars(config['redis_url'])

    redis_obj = StrictRedis.from_url(redis_url)

    config['redis_warc_resolver'] = DynRedisResolver(redis_obj,
                                                     remote_target=config['remote_target'],
                                                     proxy_target=config['proxy_target'])


    bottle_app = default_app()

    final_app, cork = init_cork(bottle_app, redis_obj, config)

    webrec = WebRec(config, cork, redis_obj)
    bottle_app.install(webrec)

    pywb_dispatch = PywbDispatcher(bottle_app)

    init_routes(webrec)
    pywb_dispatch.init_routes()

    return final_app

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import from_url [as 别名]
 def redis(self):
     redis = getattr(flask.g, 'redis_client', None)
     if redis is None:
         url = app.config.get('CACHE_REDIS_URL')
         redis = StrictRedis.from_url(url)
         flask.g.redis_client = redis
     return redis

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import from_url [as 别名]
def redis_setup(app):
    redis_url = current_app.config.get('CACHE_REDIS_URL')
    r = StrictRedis.from_url(redis_url)

    yield r

    r.delete('legacy_orcid_tokens')

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import from_url [as 别名]
def redis_setup(api):
    redis_url = api.config.get('CACHE_REDIS_URL')
    r = StrictRedis.from_url(redis_url)

    yield r

    r.delete('orcidputcodes:0000-0002-2169-2152:4328')

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import from_url [as 别名]
def get_redis_from_config(settings):
    """Returns a StrictRedis instance from a dictionary of settings."""
    if settings.get('REDIS_URL') is not None:
        return StrictRedis.from_url(settings['REDIS_URL'])

    kwargs = {
        'host': settings.get('REDIS_HOST', 'localhost'),
        'port': settings.get('REDIS_PORT', 6379),
        'db': settings.get('REDIS_DB', 0),
        'password': settings.get('REDIS_PASSWORD', None),
    }

    use_ssl = settings.get('REDIS_SSL', False)
    if use_ssl:
        # If SSL is required, we need to depend on redis-py being 2.10 at
        # least
        def safeint(x):
            try:
                return int(x)
            except ValueError:
                return 0

        version_info = tuple(safeint(x) for x in redis.__version__.split('.'))
        if not version_info >= (2, 10):
            raise RuntimeError('Using SSL requires a redis-py version >= 2.10')
        kwargs['ssl'] = use_ssl
    return StrictRedis(**kwargs)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import from_url [as 别名]
def get_multi_karma(bot, number, reverse):
    redis = StrictRedis.from_url(bot.config['System']['redis_url'])
    all_karma = redis.hgetall(bot.config['System']['redis_prefix'] + "karma")
    all_karma = [(item[0].decode('utf-8'), int(item[1])) for item in all_karma.items()]
    sorted_karma = sorted(all_karma, key=operator.itemgetter(1), reverse=reverse)

    return sorted_karma[:number]

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import from_url [as 别名]
def continuous_migration():
    """Task to continuously migrate what is pushed up by Legacy."""
    from redis import StrictRedis
    redis_url = current_app.config.get('CACHE_REDIS_URL')
    r = StrictRedis.from_url(redis_url)

    try:
        while r.llen('legacy_records'):
            raw_record = r.lpop('legacy_records')
            if raw_record:
                # The record might be None, in case a parallel
                # continuous_migration task has already consumed the queue.
                raw_record = zlib.decompress(raw_record)
                record = marc_create_record(raw_record, keep_singletons=False)
                recid = int(record['001'][0])
                prod_record = InspireProdRecords(recid=recid)
                prod_record.marcxml = raw_record
                try:
                    with db.session.begin_nested():
                        errors, dummy = create_record(
                            record, force=True, validation=True
                        )
                        logger.info("Successfully migrated record {}".format(recid))
                        prod_record.successful = True
                        prod_record.valid = not errors
                        prod_record.errors = errors
                        db.session.merge(prod_record)
                except Exception as err:
                    logger.error("Error when migrating record {}".format(recid))
                    logger.exception(err)
                    prod_record.successful = False
                    db.session.merge(prod_record)
    finally:
        db.session.commit()
        db.session.close()

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import from_url [as 别名]
def message_hook(bot, channel, sender, message):
    listen_on = bot.config['Slack']['listen'].split()
    if channel in listen_on and not sender.startswith("["):
        redis = StrictRedis.from_url(bot.config['System']['redis_url'])
        redis_key = bot.config['System']['redis_prefix'] + "slack-avatar-" + sender

        endpoint = bot.config['Slack']['webhook']
        chanstr = channel.replace("#","")
        target_channel = bot.config['Slack'][chanstr+"_target"]

        message = message.replace("\x01", "")
        message = re.sub(r'/\[([^@\ ]]+)\]/', r'@$1', message)

        payload = {
            'text': message,
            'username': sender,
            'channel': target_channel
        }

        if redis.exists(redis_key):
            payload['icon_url'] = redis.get(redis_key).decode("utf-8")

        postit = requests.post(
            endpoint,
            data=json.dumps(payload)
        )

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import from_url [as 别名]
 def prepare_session(self):
     from redis import StrictRedis
     url = self.config.get('SESSION_REDIS', None)
     if url is None:
         return
     redis = StrictRedis.from_url(url)
     self.session_interface = RedisSessionInterface(redis=redis)