feat: 支持自定义cache名字前缀

configure/__init__.py

@@ -27,6 +27,7 @@ conf = {
     "CACHE_REDIS_PASSWD": "123456",
     "CACHE_REDIS_DATABASE": 0,
     "CACHE_EXPIRE": 604800,  # 默认七天过期
+    "CACHE_PREFIX": "hblog_cache",
     "MAIL_SERVER": "",
     "MAIL_PORT": "",
     "MAIL_USE_TLS": False,

sql/cache.py

@@ -7,6 +7,7 @@ from datetime import datetime
 
 
 CACHE_TIME = int(conf["CACHE_EXPIRE"])
+CACHE_PREFIX = conf["CACHE_PREFIX"]
 
 
 def __try_redis(ret=None):
@@ -25,7 +26,7 @@ def __try_redis(ret=None):
 
 @__try_redis(None)
 def get_msg_from_cache(msg_id: int):
-    msg = cache.hgetall(f"cache:msg:{msg_id}")
+    msg = cache.hgetall(f"{CACHE_PREFIX}:msg:{msg_id}")
     if len(msg) != 4:
         return None
     return [msg.get("Email", ""),
@@ -36,7 +37,7 @@ def get_msg_from_cache(msg_id: int):
 
 @__try_redis(None)
 def write_msg_to_cache(msg_id: int, email: str, content: str, update_time: str | datetime, secret: bool):
-    cache_name = f"cache:msg:{msg_id}"
+    cache_name = f"{CACHE_PREFIX}:msg:{msg_id}"
     cache.delete(cache_name)
     cache.hset(cache_name, mapping={
         "Email": email,
@@ -49,38 +50,38 @@ def write_msg_to_cache(msg_id: int, email: str, content: str, update_time: str |
 
 @__try_redis(None)
 def delete_msg_from_cache(msg_id: int):
-    cache.delete(f"cache:msg:{msg_id}")
+    cache.delete(f"{CACHE_PREFIX}:msg:{msg_id}")
 
 
 @__try_redis(None)
 def get_msg_cout_from_cache():
-    count = cache.get("cache:msg_count")
+    count = cache.get(f"{CACHE_PREFIX}:msg_count")
     if count is not None:
         return int(count)
 
 
 @__try_redis(None)
 def write_msg_count_to_cache(count):
-    count = cache.set("cache:msg_count", str(count))
-    cache.expire("cache:msg_count", CACHE_TIME)
+    count = cache.set(f"{CACHE_PREFIX}:msg_count", str(count))
+    cache.expire(f"{CACHE_PREFIX}:msg_count", CACHE_TIME)
     return count
 
 
 @__try_redis(None)
 def delete_msg_count_from_cache():
-    cache.delete("cache:msg_count")
+    cache.delete(f"{CACHE_PREFIX}:msg_count")
 
 
 @__try_redis(None)
 def get_user_msg_count_from_cache(user_id: int):
-    count = cache.get(f"cache:msg_count:{user_id}")
+    count = cache.get(f"{CACHE_PREFIX}:msg_count:{user_id}")
     if count is not None:
         return int(count)
 
 
 @__try_redis(None)
 def write_user_msg_count_to_cache(user_id, count):
-    cache_name = f"cache:msg_count:{user_id}"
+    cache_name = f"{CACHE_PREFIX}:msg_count:{user_id}"
     count = cache.set(cache_name, str(count))
     cache.expire(cache_name, CACHE_TIME)
     return count
@@ -88,18 +89,18 @@ def write_user_msg_count_to_cache(user_id, count):
 
 @__try_redis(None)
 def delete_user_msg_count_from_cache(user_id):
-    cache.delete(f"cache:msg_count:{user_id}")
+    cache.delete(f"{CACHE_PREFIX}:msg_count:{user_id}")
 
 
 @__try_redis(None)
 def delete_all_user_msg_count_from_cache():
-    for i in cache.keys("cache:msg_count:*"):
+    for i in cache.keys(f"{CACHE_PREFIX}:msg_count:*"):
         cache.delete(i)
 
 
 @__try_redis(None)
 def get_blog_from_cache(blog_id: int):
-    blog = cache.hgetall(f"cache:blog:{blog_id}")
+    blog = cache.hgetall(f"{CACHE_PREFIX}:blog:{blog_id}")
     if len(blog) != 7:
         return None
     return [int(blog.get("Auth", -1)),
@@ -114,7 +115,7 @@ def get_blog_from_cache(blog_id: int):
 @__try_redis(None)
 def write_blog_to_cache(blog_id: int, auth_id: str, title: str, subtitle: str, content: str,
                         update_time: str | datetime, create_time: str | datetime, top: bool):
-    cache_name = f"cache:blog:{blog_id}"
+    cache_name = f"{CACHE_PREFIX}:blog:{blog_id}"
     cache.delete(cache_name)
     cache.hset(cache_name, mapping={
         "Auth": auth_id,
@@ -130,38 +131,38 @@ def write_blog_to_cache(blog_id: int, auth_id: str, title: str, subtitle: str, c
 
 @__try_redis(None)
 def delete_blog_from_cache(blog_id: int):
-    cache.delete(f"cache:blog:{blog_id}")
+    cache.delete(f"{CACHE_PREFIX}:blog:{blog_id}")
 
 
 @__try_redis(None)
 def get_blog_count_from_cache():
-    count = cache.get("cache:blog_count")
+    count = cache.get(f"{CACHE_PREFIX}:blog_count")
     if count is not None:
         return int(count)
 
 
 @__try_redis(None)
 def write_blog_count_to_cache(count):
-    count = cache.set("cache:blog_count", str(count))
-    cache.expire("cache:blog_count", CACHE_TIME)
+    count = cache.set(f"{CACHE_PREFIX}:blog_count", str(count))
+    cache.expire(f"{CACHE_PREFIX}:blog_count", CACHE_TIME)
     return count
 
 
 @__try_redis(None)
 def delete_blog_count_from_cache():
-    cache.delete("cache:blog_count")
+    cache.delete(f"{CACHE_PREFIX}:blog_count")
 
 
 @__try_redis(None)
 def get_archive_blog_count_from_cache(archive_id: int):
-    count = cache.get(f"cache:blog_count:archive:{archive_id}")
+    count = cache.get(f"{CACHE_PREFIX}:blog_count:archive:{archive_id}")
     if count is not None:
         return int(count)
 
 
 @__try_redis(None)
 def write_archive_blog_count_to_cache(archive_id, count):
-    cache_name = f"cache:blog_count:archive:{archive_id}"
+    cache_name = f"{CACHE_PREFIX}:blog_count:archive:{archive_id}"
     count = cache.set(cache_name, str(count))
     cache.expire(cache_name, CACHE_TIME)
     return count
@@ -169,25 +170,25 @@ def write_archive_blog_count_to_cache(archive_id, count):
 
 @__try_redis(None)
 def delete_all_archive_blog_count_from_cache():
-    for i in cache.keys("cache:blog_count:archive:*"):
+    for i in cache.keys(f"{CACHE_PREFIX}:blog_count:archive:*"):
         cache.delete(i)
 
 
 @__try_redis(None)
 def delete_archive_blog_count_from_cache(archive_id: int):
-    cache.delete(f"cache:blog_count:archive:{archive_id}")
+    cache.delete(f"{CACHE_PREFIX}:blog_count:archive:{archive_id}")
 
 
 @__try_redis(None)
 def get_user_blog_count_from_cache(user_id: int):
-    count = cache.get(f"cache:blog_count:user:{user_id}")
+    count = cache.get(f"{CACHE_PREFIX}:blog_count:user:{user_id}")
     if count is not None:
         return int(count)
 
 
 @__try_redis(None)
 def write_user_blog_count_to_cache(user_id, count):
-    cache_name = f"cache:blog_count:user:{user_id}"
+    cache_name = f"{CACHE_PREFIX}:blog_count:user:{user_id}"
     count = cache.set(cache_name, str(count))
     cache.expire(cache_name, CACHE_TIME)
     return count
@@ -195,18 +196,18 @@ def write_user_blog_count_to_cache(user_id, count):
 
 @__try_redis(None)
 def delete_all_user_blog_count_from_cache():
-    for i in cache.keys("cache:blog_count:user:*"):
+    for i in cache.keys(f"{CACHE_PREFIX}:blog_count:user:*"):
         cache.delete(i)
 
 
 @__try_redis(None)
 def delete_user_blog_count_from_cache(user_id: int):
-    cache.delete(f"cache:blog_count:user:{user_id}")
+    cache.delete(f"{CACHE_PREFIX}:blog_count:user:{user_id}")
 
 
 @__try_redis(None)
 def get_archive_from_cache(archive_id: int):
-    archive = cache.hgetall(f"cache:archive:{archive_id}")
+    archive = cache.hgetall(f"{CACHE_PREFIX}:archive:{archive_id}")
     if len(archive) != 2:
         return None
     return [archive.get("Name", ""), archive.get("DescribeText")]
@@ -214,7 +215,7 @@ def get_archive_from_cache(archive_id: int):
 
 @__try_redis(None)
 def write_archive_to_cache(archive_id: int, name: str, describe: str):
-    cache_name = f"cache:archive:{archive_id}"
+    cache_name = f"{CACHE_PREFIX}:archive:{archive_id}"
     cache.delete(cache_name)
     cache.hset(cache_name, mapping={
         "Name": name,
@@ -225,12 +226,12 @@ def write_archive_to_cache(archive_id: int, name: str, describe: str):
 
 @__try_redis(None)
 def delete_archive_from_cache(archive_id: int):
-    cache.delete(f"cache:archive:{archive_id}")
+    cache.delete(f"{CACHE_PREFIX}:archive:{archive_id}")
 
 
 @__try_redis(None)
 def get_blog_archive_from_cache(blog_id: int):
-    blog_archive = cache.lrange(f"cache:blog_archive:{blog_id}", 0, -1)
+    blog_archive = cache.lrange(f"{CACHE_PREFIX}:blog_archive:{blog_id}", 0, -1)
     if len(blog_archive) == 0:
         return None
     return blog_archive
@@ -238,7 +239,7 @@ def get_blog_archive_from_cache(blog_id: int):
 
 @__try_redis(None)
 def write_blog_archive_to_cache(blog_id: int, archive):
-    cache_name = f"cache:blog_archive:{blog_id}"
+    cache_name = f"{CACHE_PREFIX}:blog_archive:{blog_id}"
     cache.delete(cache_name)
     cache.rpush(cache_name, *archive)
     cache.expire(cache_name, CACHE_TIME)
@@ -246,18 +247,18 @@ def write_blog_archive_to_cache(blog_id: int, archive):
 
 @__try_redis(None)
 def delete_blog_archive_from_cache(blog_id: int):
-    cache.delete(f"cache:blog_archive:{blog_id}")
+    cache.delete(f"{CACHE_PREFIX}:blog_archive:{blog_id}")
 
 
 @__try_redis(None)
 def delete_all_blog_archive_from_cache():
-    for i in cache.keys("cache:blog_archive:*"):
+    for i in cache.keys(f"{CACHE_PREFIX}:blog_archive:*"):
         cache.delete(i)
 
 
 @__try_redis(None)
 def get_comment_from_cache(comment_id: int):
-    comment = cache.hgetall(f"cache:comment:{comment_id}")
+    comment = cache.hgetall(f"{CACHE_PREFIX}:comment:{comment_id}")
     if len(comment) != 2:
         return None
     return [comment.get("BlogID", ""),
@@ -268,7 +269,7 @@ def get_comment_from_cache(comment_id: int):
 
 @__try_redis(None)
 def write_comment_to_cache(comment_id: int, blog_id: str, email: str, content: str, update_time: str | datetime):
-    cache_name = f"cache:comment:{comment_id}"
+    cache_name = f"{CACHE_PREFIX}:comment:{comment_id}"
     cache.delete(cache_name)
     cache.hset(cache_name, mapping={
         "BlogID": blog_id,
@@ -281,19 +282,19 @@ def write_comment_to_cache(comment_id: int, blog_id: str, email: str, content: s
 
 @__try_redis(None)
 def delete_comment_from_cache(comment_id: int):
-    cache.delete(f"cache:comment:{comment_id}")
+    cache.delete(f"{CACHE_PREFIX}:comment:{comment_id}")
 
 
 @__try_redis(None)
 def get_user_comment_count_from_cache(user_id: int):
-    count = cache.get(f"cache:comment_count:{user_id}")
+    count = cache.get(f"{CACHE_PREFIX}:comment_count:{user_id}")
     if count is not None:
         return int(count)
 
 
 @__try_redis(None)
 def write_user_comment_count_to_cache(user_id, count):
-    cache_name = f"cache:comment_count:{user_id}"
+    cache_name = f"{CACHE_PREFIX}:comment_count:{user_id}"
     count = cache.set(cache_name, str(count))
     cache.expire(cache_name, CACHE_TIME)
     return count
@@ -301,18 +302,18 @@ def write_user_comment_count_to_cache(user_id, count):
 
 @__try_redis(None)
 def delete_user_comment_count_from_cache(user_id: int):
-    cache.delete(f"cache:comment_count:{user_id}")
+    cache.delete(f"{CACHE_PREFIX}:comment_count:{user_id}")
 
 
 @__try_redis(None)
 def delete_all_user_comment_count_from_cache():
-    for i in cache.keys("cache:comment_count:*"):
+    for i in cache.keys(f"{CACHE_PREFIX}:comment_count:*"):
         cache.delete(i)
 
 
 @__try_redis(None)
 def get_user_from_cache(email: str):
-    user = cache.hgetall(f"cache:user:{email}")
+    user = cache.hgetall(f"{CACHE_PREFIX}:user:{email}")
     if len(user) != 2:
         return None
     return [user.get("PasswdHash", ""),
@@ -322,7 +323,7 @@ def get_user_from_cache(email: str):
 
 @__try_redis(None)
 def write_user_to_cache(email: str, passwd_hash: str, role: int, user_id: int):
-    cache_name = f"cache:user:{email}"
+    cache_name = f"{CACHE_PREFIX}:user:{email}"
     cache.delete(cache_name)
     cache.hset(cache_name, mapping={
         "PasswdHash": passwd_hash,
@@ -334,12 +335,12 @@ def write_user_to_cache(email: str, passwd_hash: str, role: int, user_id: int):
 
 @__try_redis(None)
 def delete_user_from_cache(email: str):
-    cache.delete(f"cache:user:{email}")
+    cache.delete(f"{CACHE_PREFIX}:user:{email}")
 
 
 @__try_redis(None)
 def get_user_email_from_cache(user_id: int):
-    email = cache.get(f"cache:user_email:{user_id}")
+    email = cache.get(f"{CACHE_PREFIX}:user_email:{user_id}")
     if email is None or len(email) == 0:
         return None
     return email
@@ -347,19 +348,19 @@ def get_user_email_from_cache(user_id: int):
 
 @__try_redis(None)
 def write_user_email_to_cache(user_id: int, email: str):
-    cache_name = f"cache:user_email:{user_id}"
+    cache_name = f"{CACHE_PREFIX}:user_email:{user_id}"
     cache.set(cache_name, email)
     cache.expire(cache_name, CACHE_TIME)
 
 
 @__try_redis(None)
 def delete_user_email_from_cache(user_id: int):
-    cache.delete(f"cache:user_email:{user_id}")
+    cache.delete(f"{CACHE_PREFIX}:user_email:{user_id}")
 
 
 @__try_redis(None)
 def get_role_name_from_cache(role_id: int):
-    role_name = cache.get(f"cache:role_name:{role_id}")
+    role_name = cache.get(f"{CACHE_PREFIX}:role_name:{role_id}")
     if role_name is None or len(role_name) == 0:
         return None
     return role_name
@@ -367,18 +368,18 @@ def get_role_name_from_cache(role_id: int):
 
 @__try_redis(None)
 def write_role_name_to_cache(role_id: int, name: str):
-    cache_name = f"cache:role_name:{role_id}"
+    cache_name = f"{CACHE_PREFIX}:role_name:{role_id}"
     cache.set(cache_name, name)
     cache.expire(cache_name, CACHE_TIME)
 
 
 @__try_redis(None)
 def delete_role_name_from_cache(role_id: int):
-    cache.delete(f"cache:role_name:{role_id}")
+    cache.delete(f"{CACHE_PREFIX}:role_name:{role_id}")
 
 
 def get_role_operate_from_cache(role_id: int, operate: str):
-    res = cache.get(f"cache:operate:{role_id}:{operate}")
+    res = cache.get(f"{CACHE_PREFIX}:operate:{role_id}:{operate}")
     if res is None or len(res) == 0:
         return None
     return res == "True"
@@ -386,12 +387,12 @@ def get_role_operate_from_cache(role_id: int, operate: str):
 
 @__try_redis(None)
 def write_role_operate_to_cache(role_id: int, operate: str, res: bool):
-    cache_name = f"cache:operate:{role_id}:{operate}:"
+    cache_name = f"{CACHE_PREFIX}:operate:{role_id}:{operate}:"
     cache.set(cache_name, str(res))
     cache.expire(cache_name, CACHE_TIME)
 
 
 @__try_redis(None)
 def delete_role_operate_from_cache(role_id: int):
-    for i in cache.keys(f"cache:operate:{role_id}:*"):
+    for i in cache.keys(f"{CACHE_PREFIX}:operate:{role_id}:*"):
         cache.delete(i)