rename

Author: sanderegg

services/web/server/src/simcore_service_webserver/resource_manager/registry.py

@@ -39,7 +39,7 @@
 _RESOURCE_SUFFIX = "resources"  # points to a hash (like a dict) type
 
 
-class UserSessionDict(TypedDict):
+class UserSession(TypedDict):
     """Parts of the key used in redis for a user-session"""
 
     user_id: UserID
@@ -53,8 +53,8 @@ class ResourcesDict(TypedDict, total=False):
     socket_id: str
 
 
-AliveSessions: TypeAlias = list[UserSessionDict]
-DeadSessions: TypeAlias = list[UserSessionDict]
+AliveSessions: TypeAlias = list[UserSession]
+DeadSessions: TypeAlias = list[UserSession]
 
 
 class RedisResourceRegistry:
@@ -76,48 +76,44 @@ def app(self) -> web.Application:
         return self._app
 
     @classmethod
-    def _hash_key(cls, key: UserSessionDict) -> str:
+    def _hash_key(cls, key: UserSession) -> str:
         hash_key: str = ":".join(f"{k}={v}" for k, v in key.items())
         return hash_key
 
     @classmethod
-    def _decode_hash_key(cls, hash_key: str) -> UserSessionDict:
+    def _decode_hash_key(cls, hash_key: str) -> UserSession:
         tmp_key = (
             hash_key[: -len(f":{_RESOURCE_SUFFIX}")]
             if hash_key.endswith(f":{_RESOURCE_SUFFIX}")
             else hash_key[: -len(f":{_ALIVE_SUFFIX}")]
         )
         key = dict(x.split("=") for x in tmp_key.split(":"))
-        return UserSessionDict(**key)  # type: ignore
+        return UserSession(**key)  # type: ignore
 
     @property
     def client(self) -> aioredis.Redis:
         client: aioredis.Redis = get_redis_resources_client(self.app)
         return client
 
-    async def set_resource(
-        self, key: UserSessionDict, resource: tuple[str, str]
-    ) -> None:
+    async def set_resource(self, key: UserSession, resource: tuple[str, str]) -> None:
         hash_key = f"{self._hash_key(key)}:{_RESOURCE_SUFFIX}"
         field, value = resource
         await handle_redis_returns_union_types(
             self.client.hset(hash_key, mapping={field: value})
         )
 
-    async def get_resources(self, key: UserSessionDict) -> ResourcesDict:
+    async def get_resources(self, key: UserSession) -> ResourcesDict:
         hash_key = f"{self._hash_key(key)}:{_RESOURCE_SUFFIX}"
         fields = await handle_redis_returns_union_types(self.client.hgetall(hash_key))
         return ResourcesDict(**fields)
 
-    async def remove_resource(self, key: UserSessionDict, resource_name: str) -> None:
+    async def remove_resource(self, key: UserSession, resource_name: str) -> None:
         hash_key = f"{self._hash_key(key)}:{_RESOURCE_SUFFIX}"
         await handle_redis_returns_union_types(
             self.client.hdel(hash_key, resource_name)
         )
 
-    async def find_resources(
-        self, key: UserSessionDict, resource_name: str
-    ) -> list[str]:
+    async def find_resources(self, key: UserSession, resource_name: str) -> list[str]:
         resources: list[str] = []
         # the key might only be partialy complete
         partial_hash_key = f"{self._hash_key(key)}:{_RESOURCE_SUFFIX}"
@@ -132,7 +128,7 @@ async def find_resources(
                     resources.append(key_value)
         return resources
 
-    async def find_keys(self, resource: tuple[str, str]) -> list[UserSessionDict]:
+    async def find_keys(self, resource: tuple[str, str]) -> list[UserSession]:
         if not resource:
             return []
 
@@ -144,17 +140,17 @@ async def find_keys(self, resource: tuple[str, str]) -> list[UserSessionDict]:
             == await handle_redis_returns_union_types(self.client.hget(hash_key, field))
         ]
 
-    async def set_key_alive(self, key: UserSessionDict, timeout: int) -> None:
+    async def set_key_alive(self, key: UserSession, timeout: int) -> None:
         # setting the timeout to always expire, timeout > 0
         timeout = int(max(1, timeout))
         hash_key = f"{self._hash_key(key)}:{_ALIVE_SUFFIX}"
         await self.client.set(hash_key, 1, ex=timeout)
 
-    async def is_key_alive(self, key: UserSessionDict) -> bool:
+    async def is_key_alive(self, key: UserSession) -> bool:
         hash_key = f"{self._hash_key(key)}:{_ALIVE_SUFFIX}"
         return bool(await self.client.exists(hash_key) > 0)
 
-    async def remove_key(self, key: UserSessionDict) -> None:
+    async def remove_key(self, key: UserSession) -> None:
         await self.client.delete(
             f"{self._hash_key(key)}:{_RESOURCE_SUFFIX}",
             f"{self._hash_key(key)}:{_ALIVE_SUFFIX}",

services/web/server/src/simcore_service_webserver/resource_manager/user_sessions.py

@@ -11,7 +11,7 @@
 from .registry import (
     RedisResourceRegistry,
     ResourcesDict,
-    UserSessionDict,
+    UserSession,
     get_registry,
 )
 from .settings import ResourceManagerSettings, get_plugin_settings
@@ -69,8 +69,8 @@ class UserSessionResourcesRegistry:
     def _registry(self) -> RedisResourceRegistry:
         return get_registry(self.app)
 
-    def _resource_key(self) -> UserSessionDict:
-        return UserSessionDict(
+    def _resource_key(self) -> UserSession:
+        return UserSession(
             user_id=f"{self.user_id}",
             client_session_id=self.client_session_id or "*",
         )
@@ -198,7 +198,7 @@ async def find_users_of_resource(
         app: web.Application, key: str, value: str
     ) -> list[UserSessionID]:
         registry = get_registry(app)
-        registry_keys: list[UserSessionDict] = await registry.find_keys(
+        registry_keys: list[UserSession] = await registry.find_keys(
             resource=(key, value)
         )
         users_sessions_ids: list[UserSessionID] = [

services/web/server/tests/integration/01/test_garbage_collection.py

@@ -55,7 +55,7 @@
 from simcore_service_webserver.projects.plugin import setup_projects
 from simcore_service_webserver.resource_manager.plugin import setup_resource_manager
 from simcore_service_webserver.resource_manager.registry import (
-    UserSessionDict,
+    UserSession,
     get_registry,
 )
 from simcore_service_webserver.rest.plugin import setup_rest
@@ -354,7 +354,7 @@ async def change_user_role(
 
 class SioConnectionData(NamedTuple):
     sio: socketio.AsyncClient
-    resource_key: UserSessionDict
+    resource_key: UserSession
 
 
 async def connect_to_socketio(
@@ -369,7 +369,7 @@ async def connect_to_socketio(
     socket_registry = get_registry(client.app)
     cur_client_session_id = f"{uuid4()}"
     sio, *_ = await socketio_client_factory(cur_client_session_id, client)
-    resource_key: UserSessionDict = {
+    resource_key: UserSession = {
         "user_id": str(user["id"]),
         "client_session_id": cur_client_session_id,
     }

services/web/server/tests/unit/isolated/test_garbage_collector_core.py

@@ -21,7 +21,7 @@
 from simcore_service_webserver.garbage_collector._core_orphans import (
     remove_orphaned_services,
 )
-from simcore_service_webserver.resource_manager.registry import UserSessionDict
+from simcore_service_webserver.resource_manager.registry import UserSession
 from simcore_service_webserver.users.exceptions import UserNotFoundError
 
 MODULE_GC_CORE_ORPHANS: Final[str] = (
@@ -44,7 +44,7 @@ def mock_registry(
     user_id: UserID, project_id: ProjectID, client_session_id: str
 ) -> mock.AsyncMock:
     async def _fake_get_all_resource_keys() -> (
-        tuple[list[UserSessionDict], list[UserSessionDict]]
+        tuple[list[UserSession], list[UserSession]]
     ):
         return ([{"user_id": user_id, "client_session_id": client_session_id}], [])
 

services/web/server/tests/unit/with_dbs/01/test_resource_manager_user_sessions.py

@@ -21,7 +21,7 @@
     _ALIVE_SUFFIX,
     _RESOURCE_SUFFIX,
     RedisResourceRegistry,
-    UserSessionDict,
+    UserSession,
     get_registry,
 )
 from simcore_service_webserver.resource_manager.settings import get_plugin_settings
@@ -97,7 +97,7 @@ def _do(number: int) -> list[int]:
     ],
 )
 async def test_redis_registry_hashes(
-    redis_enabled_app: web.Application, key: UserSessionDict, hash_key: str
+    redis_enabled_app: web.Application, key: UserSession, hash_key: str
 ):
     # pylint: disable=protected-access
     assert RedisResourceRegistry._hash_key(key) == hash_key  # noqa: SLF001

services/web/server/tests/unit/with_dbs/04/garbage_collector/test_resource_manager.py

@@ -21,7 +21,7 @@
 from simcore_postgres_database.models.users import UserRole
 from simcore_service_webserver.resource_manager.registry import (
     RedisResourceRegistry,
-    UserSessionDict,
+    UserSession,
     get_registry,
 )
 from tenacity.asyncio import AsyncRetrying
@@ -98,7 +98,7 @@ async def test_websocket_resource_management(
 ):
     sio, cur_client_session_id = await create_socketio_connection(None, client)
     sid = sio.get_sid()
-    resource_key = UserSessionDict(
+    resource_key = UserSession(
         user_id=f"{logged_user['id']}", client_session_id=cur_client_session_id
     )
 
@@ -143,13 +143,13 @@ async def test_websocket_multiple_connections(
     ],
 ):
     NUMBER_OF_SOCKETS = 5
-    resource_keys: list[UserSessionDict] = []
+    resource_keys: list[UserSession] = []
 
     # connect multiple clients
     clients = []
     for socket_count in range(1, NUMBER_OF_SOCKETS + 1):
         sio, cur_client_session_id = await create_socketio_connection(None, client)
-        resource_key = UserSessionDict(
+        resource_key = UserSession(
             user_id=f"{logged_user['id']}", client_session_id=cur_client_session_id
         )
         assert await socket_registry.find_keys(("socket_id", sio.get_sid())) == [