Python StrictRedis.scan方法代码示例

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import scan [as 别名]
def main():
    print "Redis status as of:", datetime.datetime.now()
    ap = ArgumentParser(description="List a summary of Redis data structures")
    ap.add_argument('-H', '--host', default='localhost')
    ap.add_argument('-p', '--port', default=6379)
    args = ap.parse_args()
    r = StrictRedis(host=args.host, port=args.port)
    for k in sorted(r.scan()[1]):
        for kind, count in ('list', r.llen), ('sset', r.zcard), ('set', r.scard), ('hash', r.hlen):
            try:
                cnt = count(k)
                print "[%-4s] %-25s %s" % (kind, k, cnt)
            except:
                pass

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import scan [as 别名]
                        user_id=dead_chat_user.user_id,
                        type="timeout",
                        name=dead_chat_user.name,
                        text="%s's connection timed out." % dead_chat_user.name,
                    ),
                )
            print "Sent timeout message."
        db.commit()

        # Generate connected/searching counters every 10 seconds.
        if int(current_time) % 10 == 0:
            print "Generating user counters."
            connected_users = set()
            next_index = 0
            while True:
                next_index, keys = redis.scan(next_index, "chat:*:online")
                for key in keys:
                    for user_id in redis.hvals(key):
                        connected_users.add(user_id)
                if int(next_index) == 0:
                    break
            redis.set("connected_users", len(connected_users))
            searching_users = set()
            for searcher_id in redis.smembers("searchers"):
                session_id = redis.get("searcher:%s:session_id" % searcher_id)
                user_id = redis.get("session:%s" % session_id)
                if user_id is not None:
                    searching_users.add(user_id)
            redis.set("searching_users", len(searching_users))
            rouletting_users = set()
            for searcher_id in redis.smembers("roulette_searchers"):

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import scan [as 别名]

#.........这里部分代码省略.........

        if "requests_module_name" in kwargs:
            if type(kwargs["requests_module_name"]) != str:
                raise RequestsRespectfulConfigError("'requests_module_name' key must be string")

            config["requests_module_name"] = kwargs["requests_module_name"]

        return config

    @classmethod
    def configure_default(cls):
        for key in config:
            config[key] = default_config[key]

        return config

    def _perform_request(self, request_func, realms):
        self._validate_request_func(request_func)

        limited_realms = [realm for realm in realms if not self._can_perform_request(realm)]

        if not limited_realms:
            request_uuid = str(uuid.uuid4())

            for realm in realms:
                self.redis.setex(
                    name="%s:REQUEST:%s:%s" % (self.redis_prefix, realm, request_uuid),
                    time=self.realm_timespan(realm),
                    value=request_uuid
                )

            return request_func()
        else:
            raise RequestsRespectfulRateLimitedError(
                "Currently rate-limited on Realm(s): {}".format(', '.join(limited_realms)))

    def _realm_redis_key(self, realm):
        return "%s:REALMS:%s" % (self.redis_prefix, realm)

    def _fetch_realm_info(self, realm):
        redis_key = self._realm_redis_key(realm)
        return self.redis.hgetall(redis_key)

    def _requests_in_timespan(self, realm):
        return len(
            self.redis.scan(
                cursor=0,
                match="%s:REQUEST:%s:*" % (self.redis_prefix, realm),
                count=self._redis_keys_in_db() + 100
            )[1]
        )

    def _redis_keys_in_db(self):
        return self.redis.info().get("db%d" % config["redis"]["database"]).get("keys")

    def _can_perform_request(self, realm):
        return self._requests_in_timespan(realm) < (self.realm_max_requests(realm) - config["safety_threshold"])

    # Requests proxy
    def _requests_proxy(self, method, *args, **kwargs):
        realms = kwargs.pop("realms", None)
        wait = kwargs.pop("wait", False)

        if realms is None:
            raise RequestsRespectfulError("'realms' is a required kwarg")

        return self.request(lambda: getattr(requests, method)(*args, **kwargs), realms, wait=wait)

    def _requests_proxy_delete(self, *args, **kwargs):
        return self._requests_proxy("delete", *args, **kwargs)

    def _requests_proxy_get(self, *args, **kwargs):
        return self._requests_proxy("get", *args, **kwargs)

    def _requests_proxy_head(self, *args, **kwargs):
        return self._requests_proxy("head", *args, **kwargs)

    def _requests_proxy_options(self, *args, **kwargs):
        return self._requests_proxy("options", *args, **kwargs)

    def _requests_proxy_patch(self, *args, **kwargs):
        return self._requests_proxy("patch", *args, **kwargs)

    def _requests_proxy_post(self, *args, **kwargs):
        return self._requests_proxy("post", *args, **kwargs)

    def _requests_proxy_put(self, *args, **kwargs):
        return self._requests_proxy("put", *args, **kwargs)

    @staticmethod
    def _validate_request_func(request_func):
        request_func_string = inspect.getsource(request_func)
        post_lambda_string = request_func_string.split(":")[1].strip()

        if not post_lambda_string.startswith(config["requests_module_name"]) and not post_lambda_string.startswith("getattr(requests"):
            raise RequestsRespectfulError("The request lambda can only contain a requests function call")

    @staticmethod
    def _config():
        return config

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import scan [as 别名]
    class RedisTokenStore(TokenStoreBase):
        def __init__(self, configstring):
            if configstring == "":
                self.redis = StrictRedis()
            else:
                host, port, db = configstring.split(":")
                self.redis = StrictRedis(host=host, port=port, db=int(db))
            self.token_prefix = "bayes_token_"
            self.total_key = "bayes_total"
            self.seen_prefix = "bayes_seen_"
            self.expiration = 7 * 24 * 3600  # one week
            self.recalc_totals_interval = 24 * 3600  # once per day
            self.labels = ["spam", "ham"]

        def recalc_totals(self):
            """from time to time we need to reduce the totals from expired messages"""
            for label in self.labels:
                kset = set()
                pattern = self.seen_prefix + label + "*"
                start, values = self.redis.scan(0, match=pattern)
                while True:
                    start, values = self.redis.scan(start, match=pattern)
                    for v in values:
                        kset.add(v)
                    if start == "0":
                        break

                oldval = self.redis.hget(self.total_key, label)
                newval = len(kset)
                self.redis.hset(self.total_key, label, newval)
                # print "%s changed from %s to %s"%(label,oldval,newval)

        def background_recalc(self):
            # maybe another host/thread already did the recalc, sleep a while before we do it ourselves
            now = int(time.time() + random.randint(1, 20))
            self.redis.hset(self.total_key, "last_recalc", now)
            time.sleep(1)

            if self.redis.hget(self.total_key, "last_recalc") == now:
                self.recalc_totals()

        def get_(self, token, what):
            assert what in self.labels
            keyname = self.token_prefix + token
            count = self.redis.hget(keyname, what)
            try:
                return int(self.redis.hget(keyname, what))
            except:
                return 0

        def get_ham_count(self, token):
            return self.get_(token, "ham")

        def get_spam_count(self, token):
            return self.get_(token, "spam")

        def get_total_ham_count(self):
            """get the number of known ham messages"""
            try:
                return int(self.redis.hget(self.total_key, "ham"))
            except:
                return 0

        def get_total_spam_count(self):
            """get the number of known spam messages"""
            try:
                return int(self.redis.hget(self.total_key, "spam"))
            except:
                return 0

        def learn_(self, tokens, aswhat):
            assert aswhat in self.labels
            digest = sha1()
            pipeline = self.redis.pipeline()
            for t in set(tokens):
                keyname = self.token_prefix + t
                curcount = pipeline.hincrby(keyname, aswhat, 1)
                if curcount == 1:  # only expire on first insert to make sure
                    pipeline.expire(keyname, self.expiration)
                digest.update(t.encode("utf-8", "ignore"))
            pipeline.hincrby(self.total_key, aswhat, 1)
            pipeline.set(self.seen_prefix + aswhat + "_" + digest.hexdigest(), 1)
            pipeline.execute()
            if self.recalc_necessary():
                thread.start_new_thread(self.background_recalc, ())

        def recalc_necessary(self):
            last_recalc = self.redis.hget(self.total_key, "last_recalc")
            if last_recalc == None:
                last_recalc = 0
            last_recalc = int(last_recalc)
            return time.time() - last_recalc > self.recalc_totals_interval

        def learn_ham(self, tokens):
            self.learn_(tokens, "ham")

        def learn_spam(self, tokens):
            self.learn_(tokens, "spam")