Python StrictRedis.setex方法代码示例

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import setex [as 别名]
class DbRedis(Db):
    def __init__(self):
        super().__init__()
        self.redis = StrictRedis(**dbSettings)

    def generateKey(self):
        return self.redis.incr("id")

    def store(self, key, objSerial):
        self.redis.setex(key, TTL, objSerial)

    def retrieve(self, key):
        return self.redis.get(key)

    def lenList(self, name):
        return self.redis.llen(name)

    def listAppend(self, name, val):
        self.redis.lpush(name, val)

    def listPopLeft(self, name):
        return self.redis.lpop(name)

    def retrieveList(self, name):
        return self.redis.lrange(name, 0, -1)

    def removeFromList(self, name, item):
        self.redis.lrem(name, item, 0)

    def keyExists(self, key):
        return self.redis.exists(key)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import setex [as 别名]
def fetch_questions_ajax(request):
    current_user = request.user
    '''
    query the database and find out whether questionpaper is made
    or not for this user, if made then return the questions with
    shuffled choices along with the answer of user, if not then
    the same thing but answers will be empty or non existent
    '''
    questions = QuestionPaper.objects.all().filter(user=current_user)
    question_list = []
    if not questions:
        # make new questions here
        print "making new questions for the user:", current_user.username   
        question_list = make_question_paper(current_user)
        # add a session variable here that keeps track whether we are making
        # the paper for the first time or not, otherwise every page refresh
        # will result in making of new question paper for this particular user
        # another solution is to check in start whether we have received a POST or GET
        # don't do it, read the above string comment

        # start the timer!
        username = current_user.username
        key = settings.NCQS_REDIS_PREFIX+username
        seconds = settings.NCQS_TOTAL_TIME
        print "now setting the key "+key+", which will expire in "+str(seconds)+" seconds.";
        rd = StrictRedis()
        rd.setex(key, seconds, "1")
    else:
        question_list = map(get_dictionary_from_question_paper, list(questions))

    data = {"data":question_list}
    return JsonResponse(data);

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import setex [as 别名]
def polite_get(url, ttl=TTL, db=0, port=6379):

    """
    Don't hammer the remote servers.

    1. They don't update that often anyway.
    2. We don't want to get throttled or banned.
    3. It's polite.

    Accepts kwargs for ttl, db, and port; otherwise
    uses Redis defaults and a one-hour ttl.
    """

    db = StrictRedis(db=db, port=port)

    key = "url_cache::{0}".format(url)
    result = db.get(key)

    if result is None:

        page = requests.get(url)
        result = page.text
        db.setex(key, ttl, result.encode('utf-8'))

    else:
        result = result.decode('utf-8')

    return result

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import setex [as 别名]
class RedisManager(NoSqlManager):
    def __init__(self,
                 namespace,
                 url=None,
                 data_dir=None,
                 lock_dir=None,
                 **params):
        self.db = params.pop('db', None)
        self.connection_pools = {}
        NoSqlManager.__init__(self,
                              namespace,
                              url=url,
                              data_dir=data_dir,
                              lock_dir=lock_dir,
                              **params)

    def open_connection(self, host, port, **params):
        pool_key = self._format_pool_key(host, port, self.db)
        if pool_key not in self.connection_pools:
            self.connection_pools[pool_key] = ConnectionPool(host=host,
                                                             port=port,
                                                             db=self.db)
        self.db_conn = StrictRedis(connection_pool=self.connection_pools[pool_key],
                                   **params)

    def __contains__(self, key):
        return self.db_conn.exists(self._format_key(key))

    def set_value(self, key, value, expiretime=None):
        key = self._format_key(key)

        #
        # beaker.container.Value.set_value calls NamespaceManager.set_value
        # however it (until version 1.6.4) never sets expiretime param.
        #
        # Checking "type(value) is tuple" is a compromise
        # because Manager class can be instantiated outside container.py (See: session.py)
        #
        if (expiretime is None) and (type(value) is tuple):
            expiretime = value[1]

        if expiretime:
            self.db_conn.setex(key, expiretime, pickle.dumps(value, 2))
        else:
            self.db_conn.set(key, pickle.dumps(value, 2))

    def __delitem__(self, key):
        self.db_conn.delete(self._format_key(key))

    def _format_key(self, key):
        return 'beaker:%s:%s' % (self.namespace, key.replace(' ', '\302\267'))

    def _format_pool_key(self, host, port, db):
        return '{0}:{1}:{2}'.format(host, port, self.db)

    def do_remove(self):
        self.db_conn.flush()

    def keys(self):
        return self.db_conn.keys('beaker:%s:*' % self.namespace)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import setex [as 别名]
class RedisManager(NoSqlManager):
    def __init__(self,
                 namespace,
                 url=None,
                 data_dir=None,
                 lock_dir=None,
                 **params):
        self.db = params.pop('db', None)
        self.dbpass = params.pop('password', None)
        self.connection_pool = params.get('redis_connection_pool', None)
        self.expires = params.get('expires', params.get('expiretime', None))
        NoSqlManager.__init__(self,
                              namespace,
                              url=url,
                              data_dir=data_dir,
                              lock_dir=lock_dir,
                              **params)

    def open_connection(self, host, port, **params):
        if not self.connection_pool:
            self.connection_pool = ConnectionPool(host=host, port=port, db=self.db,
                    password=self.dbpass)
        self.db_conn = StrictRedis(connection_pool=self.connection_pool, **params)
    
    def __contains__(self, key):
        return self.db_conn.exists(self._format_key(key))

    def set_value(self, key, value, expiretime=None):
        key = self._format_key(key)
        # beaker.container.Value.set_value calls NamespaceManager.set_value
        # however it (until version 1.6.4) never sets expiretime param.
        #
        # Checking "type(value) is tuple" is a compromise
        # because Manager class can be instantiated outside container.py (See: session.py)
        if (expiretime is None) and (type(value) is tuple):
            expiretime = value[1]
        # If the machinery above fails, then pickup the expires time from the
        # init params.
        if not expiretime and self.expires is not None:
            expiretime = self.expires
        # Set or setex, according to whether we got an expires time or not.
        if expiretime:
            self.db_conn.setex(key, expiretime, pickle.dumps(value, 2))
        else:
            self.db_conn.set(key, pickle.dumps(value, 2))

    def __delitem__(self, key):
        self.db_conn.delete(self._format_key(key))

    def _format_key(self, key):
        return 'beaker:%s:%s' % (self.namespace, key.replace(' ', '\302\267'))

    def _format_pool_key(self, host, port, db):
        return '{0}:{1}:{2}'.format(host, port, self.db)

    def do_remove(self):
        self.db_conn.flush()

    def keys(self):
        return self.db_conn.keys('beaker:%s:*' % self.namespace)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import setex [as 别名]
class RedisManager(NoSqlManager):
    def __init__(self, namespace, url=None, data_dir=None, lock_dir=None, **params):
        self.connection_pool = params.pop('connection_pool', None)
        NoSqlManager.__init__(self, namespace, url=url, data_dir=data_dir, lock_dir=lock_dir, **params)

    def open_connection(self, host, port, **params):
        self.db_conn = StrictRedis(host=host, port=int(port), connection_pool=self.connection_pool, **params)

    def __contains__(self, key):
        log.debug('%s contained in redis cache (as %s) : %s'%(key, self._format_key(key), self.db_conn.exists(self._format_key(key))))
        return self.db_conn.exists(self._format_key(key))

    def set_value(self, key, value, expiretime=None):
        key = self._format_key(key)

        #XXX: beaker.container.Value.set_value calls NamespaceManager.set_value
        # however it(until version 1.6.3) never sets expiretime param. Why?

        if expiretime:
            self.db_conn.setex(key, expiretime, pickle.dumps(value))
        else:
            self.db_conn.set(key, pickle.dumps(value))

    def __delitem__(self, key):
        self.db_conn.delete(self._format_key(key))

    def _format_key(self, key):
        return 'beaker:%s:%s' % (self.namespace, key.replace(' ', '\302\267'))

    def do_remove(self):
        self.db_conn.flush()

    def keys(self):
        return self.db_conn.keys('beaker:%s:*' % self.namespace)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import setex [as 别名]
def archive_events():
    print("Starting to archive events.")
    redis = StrictRedis(host=REDIS_HOST, port=REDIS_PORT, db=0)
    s3 = tinys3.Connection(AWS_ACCESS_KEY_ID,
                           AWS_SECRET_ACCESS_KEY,
                           default_bucket=S3_BUCKET,
                           endpoint=S3_ENDPOINT,
                           tls=True)

    now = datetime.utcnow()
    nowstring = now.strftime("%Y-%m-%d")

    # 1. We collect all events objects from the query time span
    # and group them by day.

    # keep everything in RAM, keyed by day
    events = {}
    count = 0
    for event in fetch_events():
        event_datetime = datetime.fromtimestamp(event["created"])
        daystring = event_datetime.strftime("%Y-%m-%d")
        if daystring == nowstring:
            continue
        if daystring not in events:
            events[daystring] = []
        count += 1
        events[daystring].append(event)
    print("Fetched %d events." % count)

    # 2. We go through day by day and see where new entries have been added
    # since the last run. For these we create a backup file.

    redis_retention = REDIS_RETENTION_DAYS * 24 * 60 * 60

    for daystring in sorted(events.keys()):
        print("Processing day %s with %d events" % (daystring, len(events[daystring])))

        # possibly skip days already archived
        redis_value = redis.get(daystring)
        if redis_value is not None:
            num_entries_before = int(redis_value)
            if len(events[daystring]) <= num_entries_before:
                print("Skipping day %s, already archived" % daystring)
                continue

        try:
            target_path = upload_dump(daystring, events[daystring], s3)
            print("Uploaded %s" % target_path)
            # write number of entries per day to redis
            redis.setex(daystring, redis_retention, str(len(events[daystring])))
        except Exception as ex:
            sys.stderr.write("ERROR: No backup created for %s\n" % daystring)
            sys.stderr.write(traceback.format_exc() + "\n")

    del redis
    del s3
    del events

    print("Done for today.")

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import setex [as 别名]
class RedisManager(NoSqlManager):

    connection_pools = {}

    def __init__(self, namespace, url=None, data_dir=None, lock_dir=None, **params):
        self.db = params.pop("db", None)
        self.dbpass = params.pop("password", None)
        NoSqlManager.__init__(self, namespace, url=url, data_dir=data_dir, lock_dir=lock_dir, **params)

    def open_connection(self, host, port, **params):
        pool_key = self._format_pool_key(host, port, self.db)
        if pool_key not in self.connection_pools:
            self.connection_pools[pool_key] = ConnectionPool(host=host, port=port, db=self.db, password=self.dbpass)
        self.db_conn = StrictRedis(connection_pool=self.connection_pools[pool_key], **params)

    def __contains__(self, key):
        return self.db_conn.exists(self._format_key(key))

    def set_value(self, key, value, expiretime=None):
        key = self._format_key(key)

        #
        # beaker.container.Value.set_value calls NamespaceManager.set_value
        # however it (until version 1.6.4) never sets expiretime param.
        #
        # Checking "type(value) is tuple" is a compromise
        # because Manager class can be instantiated outside container.py (See: session.py)
        #
        if (expiretime is None) and (type(value) is tuple):
            expiretime = value[1]

        if self.serializer == "json":
            serialized_value = json.dumps(value, ensure_ascii=True)
        else:
            serialized_value = pickle.dumps(value, 2)

        if expiretime:
            self.db_conn.setex(key, expiretime, serialized_value)
        else:
            self.db_conn.set(key, serialized_value)

    def __delitem__(self, key):
        self.db_conn.delete(self._format_key(key))

    def _format_key(self, key):
        return "beaker:%s:%s" % (self.namespace, key.replace(" ", "\302\267"))

    def _format_pool_key(self, host, port, db):
        return "{0}:{1}:{2}".format(host, port, self.db)

    def do_remove(self):
        for key in self.keys():
            self.db_conn.delete(key)

    def keys(self):
        return self.db_conn.keys("beaker:%s:*" % self.namespace)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import setex [as 别名]
class Redis():
    INVITE_EXPIRATION = 300
    
    def __init__(self, host='pulsing.jhk.org', port=6379, password='wsad', db=0, **kwargs):
        super().__init__()
        self.logger = logging.getLogger(__name__)
        self.__client = StrictRedis(host=host, port=port, password=password, db=0, **kwargs)
    
    def storeInvitation(self, to_user_id, from_user_id, invitation_id, invitationType):
        expiration = datetime.utcnow() + timedelta(seconds=Redis.INVITE_EXPIRATION)
        self.__client.setex(invitation_id, '1', Redis.INVITE_EXPIRATION)
        self.__client.sadd('INVITATIONS_'+to_user_id,
                           json.dumps(getInvitation(from_user_id, invitationType, invitation_id, expiration.timestamp() * 1000.0)))

    def removeInvitation(self, user_id, invitation_id):
        s_invitations = self.__client.smembers('INVITATIONS_'+user_id)
        self.logger.debug('removeInvitation fetched - %s ', s_invitations)
        
        invitations = json.loads(s_invitations)
        self.logger.debug('removeInvitation parsed - %s ', invitations)
        
        invitation = [invite for invite in invitations if (invite['invitationId'] == invitation_id)]
        self.__client.delete(invitation_id)
        
        return invitation
        
    @property
    def client(self):
        return self.__client

    def __eq__(self, other):
        return self.__client == other.__client

    def __str__(self):
        return self.__client.__str__()

    def __hash__(self):
        return self.__client.__hash__()

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import setex [as 别名]
class RedisCache:
    #是否压缩文件 compress endcoding 编码方式，key:url value:html redis链接：client 设置缓存过期时间expires=timedelta(days=30)
    def __init__(self,client=None,compress=True,endcoding='utf-8',expires=timedelta(days=30)):
        self.client = StrictRedis(host='localhost',port=6379,db=0)
        self.compress = True
        self.endcoding =endcoding
        self.expires = expires
    #序列化 解压 解码 序列化
    def __getitem__(self,url):
        value = self.client.get(url)
        if value:
            if self.compress:
                value = zlib.decompress(value)
            return json.loads(value.decode(self.endcoding))
        else:
            raise KeyError(url+'does exit')
    #反序列化 解码 解压
    def __setitem__(self,url,html):
        data = bytes(json.dumps(html),encoding=self.endcoding)
        if self.compress:
            data = zlib.compress(data)
            #设置过期时间 setex
        self.client.setex(url,self.expires,data)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import setex [as 别名]
class WallMessage:
	def __init__(self, prefix='msg', timeout=timedelta(minutes=60)):
		self.prefix = prefix
		self.timeout = timeout
		self.r = StrictRedis(__REDIS_HOST__, port=__REDIS_PORT__)

	def post(self, message):
		try:
			key = '%(prefix)s:%(hash)s' % {'prefix': self.prefix, 'hash': uuid()}
			return {'result': True, 'message': self.r.setex(key, self.timeout, bleach.clean(message))}, 200
		except ConnectionError, e:
			return {'result': False, 'error': 'Could not connect to redis, is the server started and accepting connections on %s:%s?' % (__REDIS_HOST__, __REDIS_PORT__)}, 503
		except Exception, e:
			return {'result': False, 'error': str(e)}, 500

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import setex [as 别名]
class RedisManager(NoSqlManager):
    def __init__(self, namespace, url=None, data_dir=None, lock_dir=None, **params):
        self.db = params.pop('db', None)
        NoSqlManager.__init__(self, namespace, url=url, data_dir=data_dir, lock_dir=lock_dir, **params)

    def open_connection(self, host, port, **params):
        self.db_conn = StrictRedis(host=host, port=int(port), db=self.db, **params)

    def __contains__(self, key):
        return self.db_conn.exists(self._format_key(key))

    def set_value(self, key, value, expiretime=None):
        key = self._format_key(key)

        #XXX: beaker.container.Value.set_value calls NamespaceManager.set_value
        # however it(until version 1.6.3) never sets expiretime param. Why?
        # Fortunately we can access expiretime through value.
        # >>> value = list(storedtime, expire_argument, real_value)
        if expiretime is None:
            expiretime = value[1]

        if expiretime:
            self.db_conn.setex(key, expiretime, pickle.dumps(value))
        else:
            self.db_conn.set(key, pickle.dumps(value))

    def __delitem__(self, key):
        self.db_conn.delete(self._format_key(key))

    def _format_key(self, key):
        return 'beaker:%s:%s' % (self.namespace, key.replace(' ', '\302\267'))

    def do_remove(self):
        self.db_conn.flush()

    def keys(self):
        return self.db_conn.keys('beaker:%s:*' % self.namespace)

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

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

            config["redis"] = kwargs["redis"]

        if "safety_threshold" in kwargs:
            if type(kwargs["safety_threshold"]) != int or kwargs["safety_threshold"] < 0:
                raise RequestsRespectfulConfigError("'safety_threshold' key must be a positive integer")

            config["safety_threshold"] = kwargs["safety_threshold"]

        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"])

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import setex [as 别名]
def increx(key, expire=60, incr=1):
    result = redis.incr(key, incr)
    redis.expire(key, expire)
    return result


def halt(signal=None, frame=None):
    print "Caught signal %s" % signal
    ps_thread.stop()


if __name__ == "__main__":

    print "Obtaining lock..."
    db.query(func.pg_advisory_lock(413, 4)).scalar()
    print "Lock obtained."

    load_lists()

    signal.signal(signal.SIGTERM, halt)
    signal.signal(signal.SIGINT, halt)

    ps = redis.pubsub(ignore_subscribe_messages=True)
    ps.psubscribe(**{"spamless:reload": load_lists, "channel:*": on_ps})
    ps_thread = ps.run_in_thread(sleep_time=0.01)

    while ps_thread.is_alive():
        redis.setex("spamless:alive", 10, "alive")
        ps_thread.join(3)

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

    def setUp(self):
        self.connection = StrictRedis()
        self.connection.flushall()


    @patch('pybossa.api.task_run.get_user_id_or_ip')
    def test_check_task_requested_by_user_authenticated_key_exists(self, user):
        """_check_task_requested_by_user should return True for an authorized
        user that requested a task"""
        user.return_value = {'user_id': 33, 'user_ip': None}
        taskrun = TaskRun(task_id=22)
        key = 'pybossa:task_requested:user:33:task:22'
        self.connection.setex(key, 10, True)

        check = _check_task_requested_by_user(taskrun, self.connection)

        assert check is True, check


    @patch('pybossa.api.task_run.get_user_id_or_ip')
    def test_check_task_requested_by_user_anonymous_key_exists(self, user):
        """_check_task_requested_by_user should return True for an anonymous
        user that requested a task"""
        user.return_value = {'user_id': None, 'user_ip': '127.0.0.1'}
        taskrun = TaskRun(task_id=22)
        key = 'pybossa:task_requested:user:127.0.0.1:task:22'
        self.connection.setex(key, 10, True)

        check = _check_task_requested_by_user(taskrun, self.connection)

        assert check is True, check


    @patch('pybossa.api.task_run.get_user_id_or_ip')
    def test_check_task_requested_by_user_wrong_key(self, user):
        """_check_task_requested_by_user should return False for a user that did
        not request a task"""
        user.return_value = {'user_id': 33, 'user_ip': None}
        taskrun = TaskRun(task_id=22)
        key = 'pybossa:task_requested:user:88:task:44'
        self.connection.setex(key, 10, True)

        check = _check_task_requested_by_user(taskrun, self.connection)

        assert check is False, check


    @patch('pybossa.api.task_run.get_user_id_or_ip')
    def test_check_task_requested_by_user_authenticated_deletes_key(self, user):
        """_check_task_requested_by_user deletes the key after checking that 
        an authenticated user requested the task"""
        user.return_value = {'user_id': 33, 'user_ip': None}
        taskrun = TaskRun(task_id=22)
        key = 'pybossa:task_requested:user:33:task:22'
        self.connection.setex(key, 10, True)

        _check_task_requested_by_user(taskrun, self.connection)
        key_deleted = self.connection.get(key) is None

        assert key_deleted is True, key_deleted


    @patch('pybossa.api.task_run.get_user_id_or_ip')
    def test_check_task_requested_by_user_anonymous_preserves_key(self, user):
        """_check_task_requested_by_user does not delete the key after checking
        that an anonymous user requested the task (in case many simultaneous
        anonymous users are sharing the same IP"""
        user.return_value = {'user_id': None, 'user_ip': '127.0.0.1'}
        taskrun = TaskRun(task_id=22)
        key = 'pybossa:task_requested:user:127.0.0.1:task:22'
        self.connection.setex(key, 10, True)

        _check_task_requested_by_user(taskrun, self.connection)
        key_deleted = self.connection.get(key) is None

        assert key_deleted is False, key_deleted