Python StrictRedis.zremrangebyscore方法代码示例

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zremrangebyscore [as 别名]
class RedisDB(object):

    def __init__(self):
        if not hasattr(RedisDB, 'pool'):
            RedisDB.createPool()
        self.r = StrictRedis(connection_pool = RedisDB.pool)

    @staticmethod  
    def createPool():  
        RedisDB.pool = redis.ConnectionPool(  
        host = '127.0.0.1',  
        port = 6379,  
        db   = 0
        )

    def saveToRedis(self, receiver, to_station_ab, to_station_name, from_station_ab, from_station_name, querydate, purpose_code, noticetime, publishtime):
        '''将需要抓取的信息存入redis'''
        uid = self.r.incr('uid')    
        tickets_info = {'uid':uid, 'receiver':receiver, 'to_station_ab':to_station_ab, 'to_station_name':to_station_name, 'from_station_ab':from_station_ab,'from_station_name':from_station_name, 'querydate':querydate, 'purpose_code':purpose_code, 'noticetime':noticetime, 'publishtime': publishtime}
        self.r.zadd('email_que_set_all', uid, str(tickets_info))
        if noticetime == '9am':
            self.r.zadd('email_que_set_9am', uid, str(tickets_info))
        elif noticetime == '11am':
            self.r.zadd('email_que_set_11am', uid, str(tickets_info))
        elif noticetime == '3pm':
            self.r.zadd('email_que_set_3pm', uid, str(tickets_info))
        elif noticetime == '5pm':
            self.r.zadd('email_que_set_5pm', uid, str(tickets_info))
        self.r.save()

    def getStation(self, set, name):
        return self.r.hget(set, name)

    def zrevrange(self, set, begin, end):
        return self.r.zrevrange(set, begin, end)
    
    def zremrangebyscore(self, queue, uid):
        return self.r.zremrangebyscore(queue, uid, uid)

    def station_validate(self, form, field):  
        ''' 
        表单tostation和tostation验证函数
        '''
        if not self.r.getStation(field.data):
     
            raise ValidationError(u'木有这个站') 

    def saveJSONToSet(self, setName, json):
        if not self.r.exists(setName):
            for i, name in enumerate(json):
                self.r.hset(setName, name, json[name])
                print 'insert'+name
            self.r.save()
        else:
            pass

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zremrangebyscore [as 别名]
class CacheModule(BaseCacheModule):
    """
    A caching module backed by redis.

    Keys are maintained in a zset with their score being the timestamp
    when they are inserted. This allows for the usage of 'zremrangebyscore'
    to expire keys. This mechanism is used or a pattern matched 'scan' for
    performance.
    """
    def __init__(self, *args, **kwargs):
        if C.CACHE_PLUGIN_CONNECTION:
            connection = C.CACHE_PLUGIN_CONNECTION.split(':')
        else:
            connection = []

        self._timeout = float(C.CACHE_PLUGIN_TIMEOUT)
        self._prefix = C.CACHE_PLUGIN_PREFIX
        self._cache = StrictRedis(*connection)
        self._keys_set = 'ansible_cache_keys'

    def _make_key(self, key):
        return self._prefix + key

    def get(self, key):
        value = self._cache.get(self._make_key(key))
        # guard against the key not being removed from the zset;
        # this could happen in cases where the timeout value is changed
        # between invocations
        if value is None:
            self.delete(key)
            raise KeyError
        return json.loads(value)

    def set(self, key, value):
        value2 = json.dumps(value)
        if self._timeout > 0: # a timeout of 0 is handled as meaning 'never expire'
            self._cache.setex(self._make_key(key), int(self._timeout), value2)
        else:
            self._cache.set(self._make_key(key), value2)

        self._cache.zadd(self._keys_set, time.time(), key)

    def _expire_keys(self):
        if self._timeout > 0:
            expiry_age = time.time() - self._timeout
            self._cache.zremrangebyscore(self._keys_set, 0, expiry_age)

    def keys(self):
        self._expire_keys()
        return self._cache.zrange(self._keys_set, 0, -1)

    def contains(self, key):
        self._expire_keys()
        return (self._cache.zrank(self._keys_set, key) >= 0)

    def delete(self, key):
        self._cache.delete(self._make_key(key))
        self._cache.zrem(self._keys_set, key)

    def flush(self):
        for key in self.keys():
            self.delete(key)

    def copy(self):
        # TODO: there is probably a better way to do this in redis
        ret = dict()
        for key in self.keys():
            ret[key] = self.get(key)
        return ret

    def __getstate__(self):
        return dict()

    def __setstate__(self, data):
        self.__init__()

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zremrangebyscore [as 别名]
    print("Terminating due to SIGTERM")
    sys.exit(0)


if __name__ == "__main__":
    signal.signal(signal.SIGTERM, sigterm_handler)
    r = False
    while not r:
        try:
            r = StrictRedis(host="hotlist-redis", port=6379, db=0)
        except:
            print("Waiting for redis...")
            time.sleep(2)

    last_time = None

    try:
        while True:
            timestamp = time.time()
            urls = r.zrangebyscore(KEY, 0, timestamp)
            if type(urls) == list and len(urls) > 0:
                for url_key in urls:
                    r.zincrby(URL_HOTLIST_KEY, url_key, -1.0)
                num = r.zremrangebyscore(URL_HOTLIST_KEY, 0, 0.0)
                print("Removed %d old URL entries from %s" % (num, URL_HOTLIST_KEY))
                num = r.zremrangebyscore(KEY, 0, timestamp)
                print("Removed %d old URL scores from %s" % (num, KEY))
            time.sleep(INTERVAL_SECONDS)
    finally:
        print("Exiting")