fix(redis): find a workaround to socket timeout

Author: QHivert

.devcontainer/conf/redis/redis.conf

@@ -3,3 +3,5 @@
 protected-mode yes
 user default on >default
 user sogo on >sogo ~* &* +@all -SELECT
+
+loglevel debug

app/__init__.py

@@ -4,7 +4,6 @@
 from json import loads, dumps
 from json.decoder import JSONDecodeError
 
-
 from flask import Flask, request, g, Response, current_app
 from flask.typing import ResponseReturnValue
 from flask_smorest import Api, Blueprint
@@ -22,7 +21,7 @@
 import app.utils.errors as err
 from app.utils.api.ApiBaseResponse import create_api_base_response, ApiBaseResponse
 from app.utils import constants as cs
-from app.utils.logger.logger import logger
+from app.utils.logger.logger import logger, logger_api
 from app.utils.exceptions import AggravatedException
 
 #Apis
@@ -102,6 +101,16 @@ def register_before_request(base_blueprint: Blueprint, kind: str, sogo_state: in
     :rtype: _type_
     """
 
+    @base_blueprint.before_request
+    def log_entry() -> ResponseReturnValue | None:  # pylint: disable=too-many-return-statements
+        """
+        Only used in debug to log request received
+        """
+
+        # Log the information
+        logger_api.info("Received: \"%s %s %s\"", request.method, request.path, request.environ.get('SERVER_PROTOCOL', 'Unknown'))
+        return None
+        
     @base_blueprint.before_request
     def check_content_type() -> ResponseReturnValue | None:  # pylint: disable=too-many-return-statements
         """

app/api/v1/admin/ApiAdminConfig.py

@@ -6,7 +6,6 @@
 from flask.typing import ResponseReturnValue
 from flask_smorest import Blueprint
 
-from app.service import sogo_cache
 from app.interface.admin.InterfaceApiAdminConfig import InterfaceApiAdminConfig
 from app.utils.logger.logger import logger_api
 from app.utils.api.paginate_sort_filter import collection_paginate, CustomPaginateResponse
@@ -30,7 +29,6 @@ def init_admin_config() -> None:
     process : ProcessSetting = g.process_settings
     interface_api = InterfaceApiAdminConfig(process_setting=process)
     g.inter = interface_api
-    sogo_cache().set("test", "banane", 500)
 
 @blp.route("/dynamic-form")
 class ApiAdminConfig(MethodView):

app/auth/service/VoucherAdminService.py

@@ -57,7 +57,9 @@ def generate_voucher_from_admin(self, admin_uid: str) -> Any:
             cs.SESSION_LAST_SEEN: int(time.time())
         }
 
-        sogo_cache().hashset(f"admin_session:{admin_session_id}", admin_session, 30 * 60)
+        cache = sogo_cache()
+        cache.hashset(f"admin_session:{admin_session_id}", admin_session, 30 * 60)
+        cache.close()
 
         # Generate the voucher
         voucher_payload = {
@@ -139,14 +141,16 @@ def generate_admin_from_voucher(self, voucher_data: Any) -> Admin:
         try:
             admin_uid, redis_key = self.get_redis_session_key_from_voucher(voucher_data)
 
-            session_data = sogo_cache().hashget(redis_key)
+            cache = sogo_cache()
+            session_data = cache.hashget(redis_key)
             if not session_data:
                 return AdminAnonymous()
             if not admin_uid == session_data[cs.USER_UID]:
                 return AdminAnonymous()
 
             #Update ttl and lest seen
-            sogo_cache().hashset(redis_key, {cs.SESSION_LAST_SEEN: int(time.time())}, ttl=30*60)
+            cache.hashset(redis_key, {cs.SESSION_LAST_SEEN: int(time.time())}, ttl=30*60)
+            cache.close()
 
             logger_auth.info("Admin authenticated with uid: %s", admin_uid)
             return Admin(uid=admin_uid)

app/auth/service/VoucherUserService.py

@@ -62,27 +62,28 @@ def generate_voucher_from_user(self, user:User) -> Any:
             cs.SESSION_SENSITIVE: sensitive_data,
             cs.SESSION_LAST_SEEN: int(time.time())
         }
-
-        sogo_cache().hashset(f"user_session:{user_session_id}", user_session, cs.TTL_1D)
+        cache = sogo_cache()
+        cache.hashset(f"user_session:{user_session_id}", user_session, cs.TTL_1D)
         # Index the session in the sorted set so that we can paginate / sort
         # active sessions by last-activity without scanning all keys.
-        sogo_cache().zset_add(
+        cache.zset_add(
             cs.ZSET_USER_SESSIONS_ACTIVITY,
             f"user_session:{user_session_id}",
             int(time.time()),
         )
         # Index the session by uid score so that sessions can be sorted / filtered by uid.
-        sogo_cache().zset_add(
+        cache.zset_add(
             cs.ZSET_USER_SESSIONS_UID,
             f"user_session:{user_session_id}",
             string_to_sort_score(user.uid),
         )
         # Index the session by domain score so that sessions can be sorted / filtered by domain.
-        sogo_cache().zset_add(
+        cache.zset_add(
             cs.ZSET_USER_SESSIONS_DOMAIN,
             f"user_session:{user_session_id}",
             string_to_sort_score(user.domain),
         )
+        cache.close()
 
         #Generate the voucher
         voucher_payload = user.get_voucher_payload()
@@ -201,16 +202,17 @@ def _get_user_session_from_payload(self, payload:dict) -> User:
         except ValueError as e:
             raise RequestException("Session key from Voucher is not valid") from e
 
-        user_session_data = sogo_cache().hashget(f"user_session:{session_id}")
+        cache = sogo_cache()
+        user_session_data = cache.hashget(f"user_session:{session_id}")
         if not user_session_data:
             # The hash has expired but sorted-set entries may linger – clean them up.
-            sogo_cache().zset_remove(
+            cache.zset_remove(
                 cs.ZSET_USER_SESSIONS_ACTIVITY, f"user_session:{session_id}"
             )
-            sogo_cache().zset_remove(
+            cache.zset_remove(
                 cs.ZSET_USER_SESSIONS_UID, f"user_session:{session_id}"
             )
-            sogo_cache().zset_remove(
+            cache.zset_remove(
                 cs.ZSET_USER_SESSIONS_DOMAIN, f"user_session:{session_id}"
             )
             logger_auth.info("User session for %s is expired or does not exist", voucher_user_uid)
@@ -238,28 +240,29 @@ def _get_user_session_from_payload(self, payload:dict) -> User:
         # Update the last activity timestamp in both the hash and the sorted set
         new_last_seen = int(time.time())
         logger.debug("Updating last_activity for session %s: %s -> %s", session_id, user_session_data.get(cs.SESSION_LAST_SEEN), new_last_seen)
-        sogo_cache().hashset(
+        cache.hashset(
             f"user_session:{session_id}",
             {cs.SESSION_LAST_SEEN: new_last_seen},
             ttl=0
         )
-        sogo_cache().zset_add(
+        cache.zset_add(
             cs.ZSET_USER_SESSIONS_ACTIVITY,
             f"user_session:{session_id}",
             new_last_seen,
         )
         # Keep the uid score index in sync.
-        sogo_cache().zset_add(
+        cache.zset_add(
             cs.ZSET_USER_SESSIONS_UID,
             f"user_session:{session_id}",
             string_to_sort_score(user.uid),
         )
         # Keep the domain score index in sync.
-        sogo_cache().zset_add(
+        cache.zset_add(
             cs.ZSET_USER_SESSIONS_DOMAIN,
             f"user_session:{session_id}",
             string_to_sort_score(user.domain),
         )
         logger.info("From voucher get user: %s", user)
+        cache.close()
 
         return user

app/manager/cache/ClientRedis.py

@@ -2,8 +2,9 @@
 from json import dumps as json_dumps, loads as json_loads
 from json.decoder import JSONDecodeError
 from typing import cast, Type
+import logging
 
-from redis import Redis, exceptions as rexc
+from redis import Redis, exceptions as rexc, ConnectionPool
 from redis.cache import CacheConfig
 from yarl import URL
 
@@ -21,6 +22,9 @@
     cs.USER_DOMAIN:       cs.ZSET_USER_SESSIONS_DOMAIN,
 }
 
+# redis_logger = logging.getLogger("redis")
+# redis_logger.setLevel(logging.DEBUG)
+
 class ClientRedis():
     """
     Client for redis, the cache system
@@ -165,7 +169,7 @@ def hashset(self, key:str, data: dict, ttl: int) -> bool:
         :param ttl: _description_
         :type ttl: int
         """
-
+        logger_cache.info("Hashset cached for key '%s'", key)
         self.redis.hset(key, mapping=data)
         if ttl > 0:
             self.redis.expire(key, ttl)
@@ -181,6 +185,7 @@ def hashget(self, key:str) -> dict|None:
         :return: _description_
         :rtype: dict|None
         """
+        logger_cache.info("Hashget cached for key '%s'", key)
         ret = cast(dict|None, self.redis.hgetall(key))
         if ret:
             logger_cache.info("Hashget cached value '%s' for key '%s'", ret, key)
@@ -534,3 +539,9 @@ def revoke_user_sessions_by_activity(self, timestamp: int) -> int:
             revoked_count, timestamp,
         )
         return revoked_count
+
+    def close(self) -> None:
+        """
+        _summary_
+        """
+        self.redis.close()

app/module/admin/ModuleAdminAuth.py

@@ -73,3 +73,4 @@ def logout_admin(self, voucher_data: str) -> None:
 
         cache = sogo_cache()
         cache.revoke_user_sessions_by_key([redis_key])
+        cache.close()

app/module/admin/ModuleAdminUser.py

@@ -47,6 +47,7 @@ def get_active_users(self, collection_param: CollectionPaginateArgs) -> tuple[in
             sort_by=collection_param.sort_by,
             sort_order=collection_param.sort_order
         )
+        cache.close()
 
         logger.debug("%d active user session(s) (total: %d)", len(active_users), total_count)
         return total_count, active_users
@@ -85,10 +86,13 @@ def revoke_users(self, uids: list[str] | None = None, redis_keys: list[str] | No
             logger.debug("Revoked %d session(s) for redis key(s): %s", revoked_count, redis_keys)
             return revoked_count
 
+        cache.close()
+
         raise RequestException(
             "Exactly one of 'uid' or 'redis_key' must be provided",
             error=err.ERROR_REVOKE_BODY_INVALID,
         )
+        
 
     def revoke_inactive_users(self, timestamp: int) -> int:
         """
@@ -105,5 +109,7 @@ def revoke_inactive_users(self, timestamp: int) -> int:
 
         revoked_count = cache.revoke_user_sessions_by_activity(timestamp)
 
+        cache.close()
+
         logger.debug("Revoked %d inactive session(s) older than %d", revoked_count, timestamp)
         return revoked_count

app/module/auth/ModuleAuth.py

@@ -6,6 +6,7 @@
 from app.auth.service.VoucherUserService import VoucherUserService
 from app.config.db import tables as tbl
 from app.config.settings.DomainSettings import AuthSettings, AuthSettingsObj, UserSourceSettings, UserSourceSettingsObj
+from app.service import sogo_cache
 from app.utils.db.Condition import EqualCondition
 from app.utils.exceptions import RequestException
 from app.utils.strings import get_domain_from_mail
@@ -166,6 +167,6 @@ def logout_user(self, voucher_data: str) -> None:
         voucher_user_service = VoucherUserService(self.process_settings)
         redis_key = voucher_user_service.get_redis_session_key_from_voucher(voucher_data)
 
-        from app.service import sogo_cache
         cache = sogo_cache()
         cache.revoke_user_sessions_by_key([redis_key])
+        cache.close()

app/service.py

@@ -1,3 +1,4 @@
+from app.config.settings.ProcessSetting import process_config
 from app.manager.agent.ClientAgent import ClientAgent
 from app.manager.cache.ClientRedis import ClientRedis
 from app.utils import exceptions as exc
@@ -13,8 +14,13 @@ def sogo_cache() -> ClientRedis:
     Using this method instead of "from app import cache_client" avoid the warning
     for potential None value.
     """
-    if isinstance(cache_client, ClientRedis):
-        return cache_client
+    #TODO there is a bug with one instance of the client, fallbacl to instaniate each time
+    # if isinstance(cache_client, ClientRedis):
+    #     return cache_client
+    
+    #Init a fresh redis client each time
+    redis_conf = process_config.get_redis_settings()
+    return ClientRedis(**redis_conf)
     raise exc.AggravatedException("Cache not instantiated when needed")
 
 def set_cache(new_cache: ClientRedis) -> None: