ruffing

Author: sanderegg

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

@@ -117,11 +117,11 @@ async def find_keys(self, resource: tuple[str, str]) -> list[UserSession]:
             == await handle_redis_returns_union_types(self.client.hget(hash_key, field))
         ]
 
-    async def set_key_alive(self, key: UserSession, timeout: int) -> None:
+    async def set_key_alive(self, key: UserSession, *, expiration_time: int) -> None:
         # setting the timeout to always expire, timeout > 0
-        timeout = int(max(1, timeout))
+        expiration_time = int(max(1, expiration_time))
         hash_key = f"{key.to_redis_hash_key()}:{ALIVE_SUFFIX}"
-        await self.client.set(hash_key, 1, ex=timeout)
+        await self.client.set(hash_key, 1, ex=expiration_time)
 
     async def is_key_alive(self, key: UserSession) -> bool:
         hash_key = f"{key.to_redis_hash_key()}:{ALIVE_SUFFIX}"

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

@@ -83,7 +83,9 @@ async def set_socket_id(self, socket_id: str) -> None:
         # NOTE: hearthbeat is not emulated in tests, make sure that with very small GC intervals
         # the resources do not expire; this value is usually in the order of minutes
         timeout = max(3, _get_service_deletion_timeout(self.app))
-        await self._registry.set_key_alive(self._resource_key(), timeout)
+        await self._registry.set_key_alive(
+            self._resource_key(), expiration_time=timeout
+        )
 
     async def get_socket_id(self) -> str | None:
         _logger.debug(
@@ -100,7 +102,7 @@ async def user_pressed_disconnect(self) -> None:
         """When the user disconnects expire as soon as possible the alive key
         to ensure garbage collection will trigger in the next 2 cycles."""
 
-        await self._registry.set_key_alive(self._resource_key(), 1)
+        await self._registry.set_key_alive(self._resource_key(), expiration_time=1)
 
     async def remove_socket_id(self) -> None:
         _logger.debug(
@@ -112,14 +114,16 @@ async def remove_socket_id(self) -> None:
 
         await self._registry.remove_resource(self._resource_key(), _SOCKET_ID_FIELDNAME)
         await self._registry.set_key_alive(
-            self._resource_key(), _get_service_deletion_timeout(self.app)
+            self._resource_key(),
+            expiration_time=_get_service_deletion_timeout(self.app),
         )
 
     async def set_heartbeat(self) -> None:
         """Extends TTL to avoid expiration of all resources under this session"""
 
         await self._registry.set_key_alive(
-            self._resource_key(), _get_service_deletion_timeout(self.app)
+            self._resource_key(),
+            expiration_time=_get_service_deletion_timeout(self.app),
         )
 
     async def find_socket_ids(self) -> list[str]:

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

@@ -359,7 +359,7 @@ class SioConnectionData(NamedTuple):
 
 async def connect_to_socketio(
     client: TestClient,
-    user,
+    user: UserInfoDict,
     socketio_client_factory: Callable[
         [str | None, TestClient | None], Awaitable[tuple[socketio.AsyncClient, str]]
     ],
@@ -369,10 +369,9 @@ 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: UserSession = {
-        "user_id": str(user["id"]),
-        "client_session_id": cur_client_session_id,
-    }
+    resource_key = UserSession(
+        user_id=user["id"], client_session_id=cur_client_session_id
+    )
     sid = sio.get_sid()
     assert sid
     assert await socket_registry.find_keys(("socket_id", sid)) == [resource_key]

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

@@ -99,7 +99,7 @@ async def test_websocket_resource_management(
     sio, cur_client_session_id = await create_socketio_connection(None, client)
     sid = sio.get_sid()
     resource_key = UserSession(
-        user_id=f"{logged_user['id']}", client_session_id=cur_client_session_id
+        user_id=logged_user["id"], client_session_id=cur_client_session_id
     )
 
     assert await socket_registry.find_keys(("socket_id", sio.get_sid())) == [
@@ -150,7 +150,7 @@ async def test_websocket_multiple_connections(
     for socket_count in range(1, NUMBER_OF_SOCKETS + 1):
         sio, cur_client_session_id = await create_socketio_connection(None, client)
         resource_key = UserSession(
-            user_id=f"{logged_user['id']}", client_session_id=cur_client_session_id
+            user_id=logged_user["id"], client_session_id=cur_client_session_id
         )
         assert await socket_registry.find_keys(("socket_id", sio.get_sid())) == [
             resource_key
@@ -161,7 +161,7 @@ async def test_websocket_multiple_connections(
         assert (
             len(
                 await socket_registry.find_resources(
-                    {"user_id": str(logged_user["id"]), "client_session_id": "*"},
+                    UserSession(user_id=logged_user["id"], client_session_id="*"),
                     "socket_id",
                 )
             )

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

@@ -183,10 +183,12 @@ async def test_redis_registry(
     STILL_ALIVE_KEY_TIMEOUT = DEAD_KEY_TIMEOUT + 1
 
     # create a key which will be alive when testing
-    await redis_registry.set_key_alive(user_session, STILL_ALIVE_KEY_TIMEOUT)
+    await redis_registry.set_key_alive(
+        user_session, expiration_time=STILL_ALIVE_KEY_TIMEOUT
+    )
     assert await redis_registry.is_key_alive(user_session) is True
     # create soon to be dead key
-    await redis_registry.set_key_alive(user_session2, DEAD_KEY_TIMEOUT)
+    await redis_registry.set_key_alive(user_session2, expiration_time=DEAD_KEY_TIMEOUT)
     alive_keys, dead_keys = await redis_registry.get_all_resource_keys()
     assert not dead_keys
     assert all(x in alive_keys for x in [user_session, user_session2])
@@ -225,8 +227,8 @@ def get_random_int():
         await redis_registry.set_resource(first_key, resource)
         await redis_registry.set_resource(second_key, resource)
 
-    await redis_registry.set_key_alive(first_key, 0)
-    await redis_registry.set_key_alive(second_key, -3000)
+    await redis_registry.set_key_alive(first_key, expiration_time=0)
+    await redis_registry.set_key_alive(second_key, expiration_time=-3000)
 
     async for attempt in AsyncRetrying(
         wait=wait_fixed(0.1),