def _pipeline(self): """ Redis list pipeline getter. A pipeline is a buffer. """ try: b = self._pipeline_cache except AttributeError: r = open_redis_connection() b = self._pipeline_cache = r.pipeline() return b
def iterate(self): """ Iterate over the Redis list. Return an iterator object which iterates over `Redis<Provider>Entry` objects. """ r = open_redis_connection() pipeline = r.pipeline() def _lpop(): """ Pop from the head of the Redis list and get the hash entry. Convert the pop and hash items to a `Redis<Provider>Entry` instance. """ entry_id = r.lpop(self._list_name) if not entry_id: # The list has been completely consumed. return None hash_name = '{}:{}'.format(self._list_name, entry_id.decode(encoding='UTF-8')) entry_dict = r.hgetall(hash_name) # Delete the hash through a pipeline. The use of a pipeline is to avoid a sort # of bug. The bug was the following: # entry = r.hgetall(hash_name) -- READ # r.delete(hash_name) -- DELETE # Sometimes the DELETE happens before the READ causing the read value to be None: this # is very very weird, but it happened sometimes. Using a pipeline solve this. pipeline.delete(hash_name) return self._init_redis_provider_entry(entry_id, entry_dict) def _lpop_mgr(): """ Wrap _lpop in a try-except block to make sure the pipeline is executed even in case of exception. """ try: item = _lpop() if not item: pipeline.execute() return item except: pipeline.execute() raise # The first argument of iter must be a callable, that's why we created the _lpop() # closure. This closure will be called for each iteration and the result is returned # until the result is None. return iter(_lpop_mgr, None)
def redis_print(args): from utils.redis import open_redis_connection redis = open_redis_connection() if args.bearertoken_id: print("Printing Redis keys for bearertoken_id: {}.".format(args.bearertoken_id)) lists = redis.keys('*token:{}'.format(args.bearertoken_id)) if not lists: sizel = 0 print("\n * NO LIST") # It should be only one list, but you never know... for list in lists: items = redis.lrange(list, 0 , -1) sizel = len(items) print("\n * THE LIST {} CONTAINS {} ITEMS:".format(list, sizel)) print(items) hashes = redis.keys('*token:{}:*'.format(args.bearertoken_id)) if not hashes: print("\n * NO HASHES") else: print("\n * THE HASHES ARE:") for hash_ in hashes: print(redis.hgetall(hash_)) print("\n * CHECKS:") # Check that there is only 1 list like: *token:x size = len(lists) msg = 'OK' if size in [1, 0] else 'NOK!!!!!' print("{} list(s) found - {}".format(size, msg)) # Check that the size of the list is = the number of hashes like *token:x:* sizeh = len(hashes) msg = 'OK' if sizel == sizeh else 'NOK!!!!!' print("{} items in the list, {} hashes - {}".format(sizel, sizeh, msg)) if args.all: print(" * PRINTING ALL REDIS KEYS:") keys = redis.keys('*') for key in keys: print(key.decode('utf-8')) print("\n * {} KEYS FOUND".format(len(keys))) print('\nDone.')
def redis_flush(args): print("Flushing Redis keys...") from utils.redis import open_redis_connection redis = open_redis_connection() redis.flushall() print('Done.')