def main():
r = StrictRedis()
r.config_set('notify-keyspace-events', 'Ex')
p = r.pubsub(ignore_subscribe_messages=True)
p.psubscribe(**{'__keyevent@0__:expired': callback})
# pop the subscribe message
p.get_message()
for message in p.listen():
pass
class Cache():
def __init__(self, host: str = 'localhost', port: int = 6379) -> None:
self.__client = StrictRedis(host, port=port, decode_responses=True)
self.__client.config_set('maxmemory', '600mb')
self.__client.config_set('maxmemory-policy', 'allkeys-lru')
self.__cache = RedisCache(redis_client=self.__client)
self.__logger = Logger().getLogger(__file__)
self.__logger.info("Initialize Cache.")
def key_exists(self, *args):
serialized_data = dumps([args[1:], {}])
key = f'rc:{args[0]}:{serialized_data}'
return self.__client.exists(key) >= 1
def get_all_keys(self):
return self.__client.keys()
def get_key_count(self):
return len(self.get_all_keys())
def __call__(self, ttl=60 * 60 * 24 * 7, limit=5000, namespace=None):
return self.__cache.cache(ttl, limit, namespace)
FOLDER_ROOT_DIR = "/tmp/redr/"
rclient = StrictRedis()
try:
conn = pymongo.MongoClient()
print("Connected successfully!!!")
except pymongo.errors.ConnectionFailure as e:
print("Could not connect to MongoDB: %s" % e)
import sys
sys.exit()
db = conn.redrdb
rclient.config_set('notify-keyspace-events', 'Ex')
token = re.compile('[a-z]{4}')
ps = rclient.pubsub()
ps.subscribe(['__keyevent@0__:expired'])
for item in ps.listen():
if item['type'] == 'message':
key = item['data'].decode()
print('received key event for ' + key)
if token.fullmatch(key):
print('added ' + key + ' to free list')
rclient.rpush('tokenfreelist', pickle.dumps(key))
link = db.links.find_one({'token': key})
if link:
class QueueServer(object):
HANDLERS_MAP = {}
def __init__(self,
host='localhost',
port=6379,
db=0,
password=None,
key=None,
error_key=None):
self.db = db
self.key = key or '/simple/queue/eventbus'
self.error_key = error_key or '/simple/queue/error/event'
self.redis = StrictRedis(host=host,
port=port,
db=db,
password=password,
decode_responses=True)
status = self.redis.config_set('notify-keyspace-events', 'AKE')
print("SET notify-keyspace-events AKE is", status)
@property
def instance_keys(self):
return {'key': self.key, 'error_key': self.error_key}
def execute_handler(self, event_key, **kwargs):
handler = self.HANDLERS_MAP.get(event_key, None)
if handler:
print(f'exec: {event_key}')
handler(**kwargs)
else:
print(f'No handler for {event_key}')
def listen(self):
pubsub = self.redis.pubsub()
pubsub.psubscribe(f'__keyspace@{self.db}__:{self.key}')
for msg in pubsub.listen():
if msg.get('data') != 'lpush':
continue
event = self.redis.rpoplpush(self.key, self.error_key)
while event:
try:
event_data = loads(event)
event_key = event_data.pop('event_handler_key')
self.execute_handler(event_key, **event_data)
self.redis.lrem(self.error_key, 0, event) # rem safe bak
except Exception as err:
print(err)
print(''.join(traceback.format_exception(*sys.exc_info())))
event = self.redis.rpoplpush(self.key, self.error_key)
self.redis.lrem(self.error_key, 0, event) # rem safe bak
async def async_execute_handler(self, event_key, **kwargs):
handler = self.HANDLERS_MAP.get(event_key, None)
if handler:
print(f'exec: {event_key}')
await handler(**kwargs)
else:
print(f'No handler for {event_key}')
async def _alisten(self):
pubsub = self.redis.pubsub()
pubsub.psubscribe(f'__keyspace@{self.db}__:{self.key}')
for msg in pubsub.listen():
if msg.get('data') != 'lpush':
continue
event = self.redis.rpoplpush(self.key, self.error_key)
while event:
try:
event_data = loads(event)
event_key = event_data.pop('event_handler_key')
await self.async_execute_handler(event_key, **event_data)
self.redis.lrem(self.error_key, 0, event) # rem safe bak
except Exception as err:
print(err)
print(''.join(traceback.format_exception(*sys.exc_info())))
event = self.redis.rpoplpush(self.key, self.error_key)
self.redis.lrem(self.error_key, 0, event)
def add_handlers(self, handler_map):
self.HANDLERS_MAP.update(handler_map)
def alisten(self):
io_loop = asyncio.get_event_loop()
io_loop.run_until_complete(self._alisten())
]).strip(), 'utf-8').strip("\'")
print("Social: ", ip)
name = 'social'
if (str(sys.argv[1]) == 'c'):
ip = str(
subprocess.check_output([
"sudo", "docker", "inspect", "-f",
"'{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}'",
"socialnetwork_compose-post-redis_1"
]).strip(), 'utf-8').strip("\'")
print("Compose: ", ip)
name = 'compose'
#redis = StrictRedis(host='localhost', port=6379)
redis = StrictRedis(host=ip, port=6379)
redis.config_set('maxmemory', str(sys.argv[2]))
redis.config_set('maxmemory-policy', 'allkeys-lru')
redis.config_set('notify-keyspace-events', 'AKEm')
pubsub = redis.pubsub()
pubsub.psubscribe('__keyspace@0__:*')
# Initialize local total tallies to 0
totalMisses = 0
totalEvictions = 0
totalZadds = 0
totalDels = 0
# Create new file with current time stamp as name
ts = str(
subprocess.check_output(["date", "--rfc-3339=seconds"]).strip(),
'utf-8').strip("\'")
