adding tests

Author: matusdrobuliak66

packages/models-library/src/models_library/rabbitmq_messages.py

@@ -201,6 +201,7 @@ class DynamicServiceRunningMessage(RabbitMessageBase):
 
     project_id: ProjectID
     node_id: NodeID
+    user_id: UserID
     product_name: ProductName | None
     created_at: datetime.datetime = Field(
         default_factory=lambda: arrow.utcnow().datetime,

services/dynamic-sidecar/src/simcore_service_dynamic_sidecar/modules/resource_tracking/_core.py

@@ -81,6 +81,7 @@ async def _heart_beat_task(app: FastAPI):
         dyn_message = DynamicServiceRunningMessage(
             project_id=settings.DY_SIDECAR_PROJECT_ID,
             node_id=settings.DY_SIDECAR_NODE_ID,
+            user_id=settings.DY_SIDECAR_USER_ID,
             product_name=settings.DY_SIDECAR_PRODUCT_NAME,
         )
         await asyncio.gather(

services/efs-guardian/src/simcore_service_efs_guardian/core/settings.py

@@ -8,7 +8,7 @@
     LogLevel,
     VersionTag,
 )
-from pydantic import Field, PositiveInt, validator
+from pydantic import ByteSize, Field, PositiveInt, validator
 from settings_library.base import BaseCustomSettings
 from settings_library.efs import AwsEfsSettings
 from settings_library.rabbit import RabbitSettings
@@ -58,6 +58,9 @@ class ApplicationSettings(BaseCustomSettings, MixinLoggingSettings):
     EFS_GROUP_NAME: str = Field(
         description="Linux group name that the EFS and Simcore linux users are part of"
     )
+    EFS_DEFAULT_USER_SERVICE_SIZE_BYTES: ByteSize = Field(
+        default=536870912000  # 500GiB = 534GB
+    )
 
     # RUNTIME  -----------------------------------------------------------
     EFS_GUARDIAN_DEBUG: bool = Field(

services/efs-guardian/src/simcore_service_efs_guardian/services/background_tasks_setup.py

@@ -10,7 +10,7 @@
 from servicelib.redis_utils import start_exclusive_periodic_task
 
 from .background_tasks import removal_policy_task
-from .modules.redis import get_redis_client
+from .modules.redis import get_redis_lock_client
 
 _logger = logging.getLogger(__name__)
 
@@ -37,7 +37,7 @@ async def _startup() -> None:
             # Setup periodic tasks
             for task in _EFS_GUARDIAN_BACKGROUND_TASKS:
                 exclusive_task = start_exclusive_periodic_task(
-                    get_redis_client(app),
+                    get_redis_lock_client(app),
                     task["task_func"],
                     task_period=timedelta(seconds=60),  # 1 minute
                     retry_after=timedelta(seconds=60),  # 5 minutes

services/efs-guardian/src/simcore_service_efs_guardian/services/efs_manager_utils.py

@@ -28,7 +28,7 @@ async def get_size_bash_async(path) -> ByteSize:
         raise e
 
 
-async def remove_write_permissions_bash_async(path) -> ByteSize:
+async def remove_write_permissions_bash_async(path) -> None:
     try:
         # Create the subprocess
         process = await asyncio.create_subprocess_exec(
@@ -44,9 +44,7 @@ async def remove_write_permissions_bash_async(path) -> ByteSize:
         stdout, stderr = await process.communicate()
 
         if process.returncode == 0:
-            # Parse the output
-            size = ByteSize(stdout.decode().split()[0])
-            return size
+            return
         else:
             print(f"Error: {stderr.decode()}")
             raise ValueError

services/efs-guardian/src/simcore_service_efs_guardian/services/modules/redis.py

@@ -10,20 +10,20 @@
 
 def setup(app: FastAPI) -> None:
     async def on_startup() -> None:
-        app.state.redis_client_sdk = None
+        app.state.redis_lock_client_sdk = None
         settings: RedisSettings = app.state.settings.EFS_GUARDIAN_REDIS
         redis_locks_dsn = settings.build_redis_dsn(RedisDatabase.LOCKS)
-        app.state.redis_client_sdk = client = RedisClientSDK(redis_locks_dsn)
-        await client.setup()
+        app.state.redis_lock_client_sdk = lock_client = RedisClientSDK(redis_locks_dsn)
+        await lock_client.setup()
 
     async def on_shutdown() -> None:
-        redis_client_sdk: None | RedisClientSDK = app.state.redis_client_sdk
-        if redis_client_sdk:
-            await redis_client_sdk.shutdown()
+        redis_lock_client_sdk: None | RedisClientSDK = app.state.redis_lock_client_sdk
+        if redis_lock_client_sdk:
+            await redis_lock_client_sdk.shutdown()
 
     app.add_event_handler("startup", on_startup)
     app.add_event_handler("shutdown", on_shutdown)
 
 
-def get_redis_client(app: FastAPI) -> RedisClientSDK:
-    return cast(RedisClientSDK, app.state.redis_client_sdk)
+def get_redis_lock_client(app: FastAPI) -> RedisClientSDK:
+    return cast(RedisClientSDK, app.state.redis_lock_client_sdk)

services/efs-guardian/src/simcore_service_efs_guardian/services/process_messages.py

@@ -3,6 +3,10 @@
 from fastapi import FastAPI
 from models_library.rabbitmq_messages import DynamicServiceRunningMessage
 from pydantic import parse_raw_as
+from simcore_service_efs_guardian.services.modules.redis import get_redis_lock_client
+
+from ..core.settings import get_application_settings
+from ..services.efs_manager import EfsManager
 
 _logger = logging.getLogger(__name__)
 
@@ -12,9 +16,33 @@ async def process_dynamic_service_running_message(app: FastAPI, data: bytes) ->
     rabbit_message: DynamicServiceRunningMessage = parse_raw_as(
         DynamicServiceRunningMessage, data  # type: ignore[arg-type]
     )
-    _logger.info(
-        "Process %s msg service_run_id: %s",
+    _logger.debug(
+        "Process dynamic service running msg, project ID: %s node ID: %s",
         rabbit_message.project_id,
         rabbit_message.node_id,
     )
+
+    settings = get_application_settings(app)
+    efs_manager: EfsManager = app.state.efs_manager
+    size = await efs_manager.get_project_node_data_size(
+        rabbit_message.project_id, node_id=rabbit_message.node_id
+    )
+
+    if size > settings.EFS_DEFAULT_USER_SERVICE_SIZE_BYTES:
+        _logger.warning(
+            "Removing write permissions inside of EFS starts for project ID: %s, node ID: %s, current user: %s",
+            rabbit_message.project_id,
+            rabbit_message.node_id,
+            rabbit_message.user_id,
+        )
+        redis = get_redis_lock_client(app)
+        async with redis.lock_context(
+            f"efs_remove_write_permissions-{rabbit_message.project_id=}-{rabbit_message.node_id=}",
+            blocking=True,
+            blocking_timeout_s=10,
+        ):
+            await efs_manager.remove_project_node_data_write_permissions(
+                project_id=rabbit_message.project_id, node_id=rabbit_message.node_id
+            )
+
     return True

services/efs-guardian/tests/unit/conftest.py

@@ -12,8 +12,10 @@
 import simcore_service_efs_guardian
 import yaml
 from asgi_lifespan import LifespanManager
+from fakeredis.aioredis import FakeRedis
 from fastapi import FastAPI
 from httpx import ASGITransport
+from pytest_mock import MockerFixture
 from pytest_simcore.helpers.monkeypatch_envs import EnvVarsDict, setenvs_from_dict
 from servicelib.rabbitmq import RabbitMQRPCClient
 from settings_library.rabbit import RabbitSettings
@@ -29,6 +31,7 @@
     "pytest_simcore.pydantic_models",
     "pytest_simcore.pytest_global_environs",
     "pytest_simcore.rabbit_service",
+    "pytest_simcore.redis_service",
     "pytest_simcore.repository_paths",
     "pytest_simcore.aws_s3_service",
     "pytest_simcore.aws_server",
@@ -139,3 +142,9 @@ async def rpc_client(
     rabbitmq_rpc_client: Callable[[str], Awaitable[RabbitMQRPCClient]],
 ) -> RabbitMQRPCClient:
     return await rabbitmq_rpc_client("client")
+
+
+@pytest.fixture
+async def mocked_redis_server(mocker: MockerFixture) -> None:
+    mock_redis = FakeRedis()
+    mocker.patch("redis.asyncio.from_url", return_value=mock_redis)

services/efs-guardian/tests/unit/test_api_health.py

@@ -28,7 +28,11 @@ def app_environment(
     )
 
 
-async def test_healthcheck(rabbit_service: RabbitSettings, client: httpx.AsyncClient):
+async def test_healthcheck(
+    rabbit_service: RabbitSettings,
+    mocked_redis_server,
+    client: httpx.AsyncClient,
+):
     response = await client.get("/")
     response.raise_for_status()
     assert response.status_code == status.HTTP_200_OK

services/efs-guardian/tests/unit/test_efs_guardian_rpc.py

@@ -0,0 +1,70 @@
+# pylint: disable=protected-access
+# pylint: disable=redefined-outer-name
+# pylint: disable=too-many-arguments
+# pylint: disable=unused-argument
+# pylint: disable=unused-variable
+
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+from faker import Faker
+from fastapi import FastAPI
+from pytest_simcore.helpers.monkeypatch_envs import setenvs_from_dict
+from pytest_simcore.helpers.typing_env import EnvVarsDict
+from servicelib.rabbitmq import RabbitMQRPCClient
+from servicelib.rabbitmq.rpc_interfaces.efs_guardian import efs_manager
+from simcore_service_efs_guardian.core.settings import AwsEfsSettings
+
+pytest_simcore_core_services_selection = ["rabbit"]
+pytest_simcore_ops_services_selection = []
+
+
+@pytest.fixture
+def app_environment(
+    monkeypatch: pytest.MonkeyPatch,
+    app_environment: EnvVarsDict,
+    rabbit_env_vars_dict: EnvVarsDict,  # rabbitMQ settings from 'rabbit' service
+) -> EnvVarsDict:
+    return setenvs_from_dict(
+        monkeypatch,
+        {
+            **app_environment,
+            **rabbit_env_vars_dict,
+        },
+    )
+
+
+async def test_rpc_create_project_specific_data_dir(
+    rpc_client: RabbitMQRPCClient,
+    faker: Faker,
+    mocked_redis_server: None,
+    app: FastAPI,
+):
+    aws_efs_settings: AwsEfsSettings = app.state.settings.EFS_GUARDIAN_AWS_EFS_SETTINGS
+
+    _project_id = faker.uuid4()
+    _node_id = faker.uuid4()
+    _storage_directory_name = faker.name()
+
+    with patch(
+        "simcore_service_efs_guardian.services.efs_manager.os.chown"
+    ) as mocked_chown:
+        result = await efs_manager.create_project_specific_data_dir(
+            rpc_client,
+            project_id=_project_id,
+            node_id=_node_id,
+            storage_directory_name=_storage_directory_name,
+        )
+        mocked_chown.assert_called_once()
+
+    assert isinstance(result, Path)
+    _expected_path = (
+        aws_efs_settings.EFS_MOUNTED_PATH
+        / aws_efs_settings.EFS_PROJECT_SPECIFIC_DATA_DIRECTORY
+        / _project_id
+        / _node_id
+        / _storage_directory_name
+    )
+    assert _expected_path == result
+    assert _expected_path.exists