class ZSet:
def __init__(self, name: str):
self.__redis = RedisClient().get_connection()
self.__zset_name = name
def add(self, username: str, value: int):
return self.__redis.zadd(self.__zset_name, {username: value},
incr=True)
def increment(self, username: str):
return self.__redis.zincrby(self.__zset_name, 1, username)
def count(self):
return self.__redis.zcard(self.__zset_name)
def get_score(self, username: str):
return self.__redis.zscore(self.__zset_name, username)
def get_all_descending(self, start: int = 0, limit: int = -1):
return [
val[0].decode("utf-8").ljust(25) + str(val[1])
for val in self.__redis.zrevrange(self.__zset_name,
start,
limit,
withscores=True,
score_cast_func=lambda x: int(x))
]
class Hash:
def __init__(self, name: str):
self.__redis = RedisClient().get_connection()
self.__hash_name = name
def delete(self, key: str):
return self.__redis.hdel(self.__hash_name, key)
def get(self, key: str):
return self.__redis.hget(self.__hash_name, key).decode("utf-8")
def set(self, key: str, value: str):
return self.__redis.hset(self.__hash_name, key, value)
def set_all(self, payload: dict):
return self.__redis.hmset(self.__hash_name, payload)
class Int:
def __init__(self, name: str):
self.__redis = RedisClient().get_connection()
self.__int_name = name
def set(self, value: int):
return self.__redis.set(self.__int_name, value)
def get(self):
return self.__redis.get(self.__int_name)
def increment(self):
return self.__redis.incr(self.__int_name)
def exists(self):
return self.get() is not None
class PubSub:
def __init__(self, name: str):
self.__redis = RedisClient().get_connection()
self.__ps = self.__redis.pubsub()
self.__pub_sub_name = name
def publish(self, msg: str):
return self.__redis.publish(self.__pub_sub_name, msg)
def subscribe(self):
return self.__ps.subscribe(self.__pub_sub_name)
def listen(self):
return self.__ps.listen()
def get_message(self):
return self.__ps.get_message()
class Set:
def __init__(self, name: str):
self.__redis = RedisClient().get_connection()
self.__set_name = name
def add(self, value: str):
return self.__redis.sadd(self.__set_name, value)
def contains(self, value: str):
return self.__redis.sismember(self.__set_name, value)
def get_all(self):
# use SSCAN to iterate when sets are to huge
return [
x.decode("utf-8") for x in self.__redis.smembers(self.__set_name)
]
def remove(self, value: str):
return self.__redis.srem(self.__set_name, value)
def get_name(self):
return self.__set_name
def union(self, set_names: [str], key_store: str):
return self.__redis.sunionstore(key_store, set_names)
def intersect(self, set_names: [str], key_store: str):
return self.__redis.sinterstore(key_store, set_names)
def move_to(self, dest: str, value: str):
return self.__redis.smove(self.__set_name, dest, value)
class List:
def __init__(self, name: str):
self.__redis = RedisClient().get_connection()
self.__list_name = name
def count(self):
return self.__redis.llen(self.__list_name)
def get_all(self, offset: int = 0, limit: int = 0):
return self.__redis.lrange(self.__list_name, offset,
offset + limit - 1)
def add(self, value: str):
return self.__redis.rpush(self.__list_name, value)
def remove(self):
return self.__redis.lpop(self.__list_name)
def remove_blocking(self):
return self.__redis.blpop(self.__list_name)[1].decode("utf-8")
def __init__(self, name: str):
self.__redis = RedisClient().get_connection()
self.__ps = self.__redis.pubsub()
self.__pub_sub_name = name
def __init__(self, name: str):
self.__redis = RedisClient().get_connection()
self.__set_name = name
client_controller.login_client(usernames[idx])
index = 0
while True:
from_username = user_prefix + str(randrange(len(usernames)))
to_username = from_username
while to_username != from_username:
to_username = user_prefix + str(randrange(len(usernames)))
message = "test-id" + str(index)
index += 1
message_controller.send_message(message, from_username, to_username)
if __name__ == "__main__":
if len(sys.argv) != 3:
print("Need two argument")
sys.exit(1)
else:
try:
count_workers = int(sys.argv[1])
max_users = int(sys.argv[2])
except Exception as e:
print(e)
sys.exit(1)
for i in range(count_workers):
thread = Thread(target=threaded_worker_function)
workers.append(thread)
thread.start()
signal.signal(signal.SIGINT, handle_interrupt_event)
RedisClient().get_connection().flushall()
send_messages(max_users)