replaced both namespaces with only a single one

Author: Andrei Neagu

packages/service-library/src/servicelib/aiohttp/long_running_tasks/_server.py

@@ -21,12 +21,7 @@
     DEFAULT_STALE_TASK_CHECK_INTERVAL,
     DEFAULT_STALE_TASK_DETECT_TIMEOUT,
 )
-from ...long_running_tasks.models import (
-    RabbitNamespace,
-    RedisNamespace,
-    TaskContext,
-    TaskGet,
-)
+from ...long_running_tasks.models import LRTNamespace, TaskContext, TaskGet
 from ...long_running_tasks.task import RegisteredTaskName
 from ..typing_extension import Handler
 from . import _routes
@@ -152,9 +147,8 @@ def setup(
     *,
     router_prefix: str,
     redis_settings: RedisSettings,
-    redis_namespace: RedisNamespace,
     rabbit_settings: RabbitSettings,
-    rabbit_namespace: RabbitNamespace,
+    lrt_namespace: LRTNamespace,
     handler_check_decorator: Callable = _no_ops_decorator,
     task_request_context_decorator: Callable = _no_task_context_decorator,
     stale_task_check_interval: datetime.timedelta = DEFAULT_STALE_TASK_CHECK_INTERVAL,
@@ -183,8 +177,7 @@ async def on_cleanup_ctx(app: web.Application) -> AsyncGenerator[None, None]:
                 stale_task_detect_timeout=stale_task_detect_timeout,
                 redis_settings=redis_settings,
                 rabbit_settings=rabbit_settings,
-                redis_namespace=redis_namespace,
-                rabbit_namespace=rabbit_namespace,
+                lrt_namespace=lrt_namespace,
             )
         )
 

packages/service-library/src/servicelib/fastapi/long_running_tasks/_server.py

@@ -9,7 +9,7 @@
     DEFAULT_STALE_TASK_DETECT_TIMEOUT,
 )
 from ...long_running_tasks.errors import BaseLongRunningError
-from ...long_running_tasks.models import RabbitNamespace, RedisNamespace
+from ...long_running_tasks.models import LRTNamespace
 from ._error_handlers import base_long_running_error_handler
 from ._manager import FastAPILongRunningManager
 from ._routes import router
@@ -20,9 +20,8 @@ def setup(
     *,
     router_prefix: str = "",
     redis_settings: RedisSettings,
-    redis_namespace: RedisNamespace,
     rabbit_settings: RabbitSettings,
-    rabbit_namespace: RabbitNamespace,
+    lrt_namespace: LRTNamespace,
     stale_task_check_interval: datetime.timedelta = DEFAULT_STALE_TASK_CHECK_INTERVAL,
     stale_task_detect_timeout: datetime.timedelta = DEFAULT_STALE_TASK_DETECT_TIMEOUT,
 ) -> None:
@@ -48,9 +47,8 @@ async def on_startup() -> None:
                 stale_task_check_interval=stale_task_check_interval,
                 stale_task_detect_timeout=stale_task_detect_timeout,
                 redis_settings=redis_settings,
-                redis_namespace=redis_namespace,
                 rabbit_settings=rabbit_settings,
-                rabbit_namespace=rabbit_namespace,
+                lrt_namespace=lrt_namespace,
             )
         )
         await long_running_manager.setup()

packages/service-library/src/servicelib/long_running_tasks/_rabbit/lrt_client.py

@@ -9,9 +9,9 @@
 from ...long_running_tasks.task import RegisteredTaskName
 from ...rabbitmq._client_rpc import RabbitMQRPCClient
 from .._serialization import string_to_object
-from ..models import RabbitNamespace, TaskBase, TaskContext, TaskId, TaskStatus
+from ..models import LRTNamespace, TaskBase, TaskContext, TaskId, TaskStatus
 from ._models import RPCErrorResponse
-from .namespace import get_namespace
+from .namespace import get_rabbit_namespace
 
 _logger = logging.getLogger(__name__)
 
@@ -26,7 +26,7 @@
 @log_decorator(_logger, level=logging.DEBUG)
 async def start_task(
     rabbitmq_rpc_client: RabbitMQRPCClient,
-    namespace: RabbitNamespace,
+    namespace: LRTNamespace,
     *,
     registered_task_name: RegisteredTaskName,
     unique: bool = False,
@@ -36,7 +36,7 @@ async def start_task(
     **task_kwargs: Any,
 ) -> TaskId:
     result = await rabbitmq_rpc_client.request(
-        get_namespace(namespace),
+        get_rabbit_namespace(namespace),
         TypeAdapter(RPCMethodName).validate_python("start_task"),
         registered_task_name=registered_task_name,
         unique=unique,
@@ -53,12 +53,12 @@ async def start_task(
 @log_decorator(_logger, level=logging.DEBUG)
 async def list_tasks(
     rabbitmq_rpc_client: RabbitMQRPCClient,
-    namespace: RabbitNamespace,
+    namespace: LRTNamespace,
     *,
     task_context: TaskContext,
 ) -> list[TaskBase]:
     result = await rabbitmq_rpc_client.request(
-        get_namespace(namespace),
+        get_rabbit_namespace(namespace),
         TypeAdapter(RPCMethodName).validate_python("list_tasks"),
         task_context=task_context,
         timeout_s=_RPC_TIMEOUT_SHORT_REQUESTS,
@@ -69,13 +69,13 @@ async def list_tasks(
 @log_decorator(_logger, level=logging.DEBUG)
 async def get_task_status(
     rabbitmq_rpc_client: RabbitMQRPCClient,
-    namespace: RabbitNamespace,
+    namespace: LRTNamespace,
     *,
     task_context: TaskContext,
     task_id: TaskId,
 ) -> TaskStatus:
     result = await rabbitmq_rpc_client.request(
-        get_namespace(namespace),
+        get_rabbit_namespace(namespace),
         TypeAdapter(RPCMethodName).validate_python("get_task_status"),
         task_context=task_context,
         task_id=task_id,
@@ -88,13 +88,13 @@ async def get_task_status(
 @log_decorator(_logger, level=logging.DEBUG)
 async def get_task_result(
     rabbitmq_rpc_client: RabbitMQRPCClient,
-    namespace: RabbitNamespace,
+    namespace: LRTNamespace,
     *,
     task_context: TaskContext,
     task_id: TaskId,
 ) -> Any:
     serialized_result = await rabbitmq_rpc_client.request(
-        get_namespace(namespace),
+        get_rabbit_namespace(namespace),
         TypeAdapter(RPCMethodName).validate_python("get_task_result"),
         task_context=task_context,
         task_id=task_id,
@@ -117,14 +117,14 @@ async def get_task_result(
 @log_decorator(_logger, level=logging.DEBUG)
 async def remove_task(
     rabbitmq_rpc_client: RabbitMQRPCClient,
-    namespace: RabbitNamespace,
+    namespace: LRTNamespace,
     *,
     task_context: TaskContext,
     task_id: TaskId,
     reraise_errors: bool = True,
 ) -> None:
     result = await rabbitmq_rpc_client.request(
-        get_namespace(namespace),
+        get_rabbit_namespace(namespace),
         TypeAdapter(RPCMethodName).validate_python("remove_task"),
         task_context=task_context,
         task_id=task_id,

packages/service-library/src/servicelib/long_running_tasks/_rabbit/namespace.py

@@ -1,8 +1,8 @@
 from models_library.rabbitmq_basic_types import RPCNamespace
 from pydantic import TypeAdapter
 
-from ..models import RabbitNamespace
+from ..models import LRTNamespace
 
 
-def get_namespace(namespace: RabbitNamespace) -> RPCNamespace:
+def get_rabbit_namespace(namespace: LRTNamespace) -> RPCNamespace:
     return TypeAdapter(RPCNamespace).validate_python(f"lrt-{namespace}")

packages/service-library/src/servicelib/long_running_tasks/base_long_running_manager.py

@@ -4,8 +4,8 @@
 from settings_library.redis import RedisSettings
 
 from ..rabbitmq._client_rpc import RabbitMQRPCClient
-from ._rabbit.namespace import get_namespace
-from .models import RabbitNamespace, RedisNamespace
+from ._rabbit.namespace import get_rabbit_namespace
+from .models import LRTNamespace
 from .task import TasksManager
 
 
@@ -20,16 +20,15 @@ def __init__(
         stale_task_detect_timeout: datetime.timedelta,
         redis_settings: RedisSettings,
         rabbit_settings: RabbitSettings,
-        redis_namespace: RedisNamespace,
-        rabbit_namespace: RabbitNamespace,
+        lrt_namespace: LRTNamespace,
     ):
         self._tasks_manager = TasksManager(
             stale_task_check_interval=stale_task_check_interval,
             stale_task_detect_timeout=stale_task_detect_timeout,
             redis_settings=redis_settings,
-            redis_namespace=redis_namespace,
+            lrt_namespace=lrt_namespace,
         )
-        self._rabbit_namespace = rabbit_namespace
+        self._lrt_namespace = lrt_namespace
         self.rabbit_settings = rabbit_settings
         self._rpc_server: RabbitMQRPCClient | None = None
         self._rpc_client: RabbitMQRPCClient | None = None
@@ -49,25 +48,25 @@ def rpc_client(self) -> RabbitMQRPCClient:
         return self._rpc_client
 
     @property
-    def rabbit_namespace(self) -> RabbitNamespace:
-        return self._rabbit_namespace
+    def lrt_namespace(self) -> LRTNamespace:
+        return self._lrt_namespace
 
     async def setup(self) -> None:
         await self._tasks_manager.setup()
         self._rpc_server = await RabbitMQRPCClient.create(
-            client_name=f"lrt-server-{self.rabbit_namespace}",
+            client_name=f"lrt-server-{self.lrt_namespace}",
             settings=self.rabbit_settings,
         )
         self._rpc_client = await RabbitMQRPCClient.create(
-            client_name=f"lrt-client-{self.rabbit_namespace}",
+            client_name=f"lrt-client-{self.lrt_namespace}",
             settings=self.rabbit_settings,
         )
 
         from ._rabbit.lrt_server import router
 
         await self.rpc_server.register_router(
             router,
-            get_namespace(self.rabbit_namespace),
+            get_rabbit_namespace(self.lrt_namespace),
             self,
         )
 

packages/service-library/src/servicelib/long_running_tasks/lrt_api.py

@@ -45,7 +45,7 @@ async def start_task(
 
     return await lrt_client.start_task(
         long_running_manager.rpc_client,
-        long_running_manager.rabbit_namespace,
+        long_running_manager.lrt_namespace,
         registered_task_name=registered_task_name,
         unique=unique,
         task_context=task_context,
@@ -62,7 +62,7 @@ async def list_tasks(
 ) -> list[TaskBase]:
     return await lrt_client.list_tasks(
         rabbitmq_rpc_client,
-        long_running_manager.rabbit_namespace,
+        long_running_manager.lrt_namespace,
         task_context=task_context,
     )
 
@@ -76,7 +76,7 @@ async def get_task_status(
     """returns the status of a task"""
     return await lrt_client.get_task_status(
         rabbitmq_rpc_client,
-        long_running_manager.rabbit_namespace,
+        long_running_manager.lrt_namespace,
         task_id=task_id,
         task_context=task_context,
     )
@@ -90,7 +90,7 @@ async def get_task_result(
 ) -> Any:
     return await lrt_client.get_task_result(
         rabbitmq_rpc_client,
-        long_running_manager.rabbit_namespace,
+        long_running_manager.lrt_namespace,
         task_context=task_context,
         task_id=task_id,
     )
@@ -105,7 +105,7 @@ async def remove_task(
     """cancels and removes the task"""
     await lrt_client.remove_task(
         rabbitmq_rpc_client,
-        long_running_manager.rabbit_namespace,
+        long_running_manager.lrt_namespace,
         task_id=task_id,
         task_context=task_context,
     )

packages/service-library/src/servicelib/long_running_tasks/models.py

@@ -28,8 +28,7 @@
 RequestBody: TypeAlias = Any
 TaskContext: TypeAlias = dict[str, Any]
 
-RabbitNamespace: TypeAlias = str
-RedisNamespace: TypeAlias = str
+LRTNamespace: TypeAlias = str
 
 
 class ResultField(BaseModel):

packages/service-library/src/servicelib/long_running_tasks/task.py

@@ -34,7 +34,7 @@
     TaskNotRegisteredError,
 )
 from .models import (
-    RedisNamespace,
+    LRTNamespace,
     ResultField,
     TaskBase,
     TaskContext,
@@ -119,17 +119,17 @@ def __init__(
         redis_settings: RedisSettings,
         stale_task_check_interval: datetime.timedelta,
         stale_task_detect_timeout: datetime.timedelta,
-        redis_namespace: RedisNamespace,
+        lrt_namespace: LRTNamespace,
     ):
         # Task groups: Every taskname maps to multiple asyncio.Task within TrackedTask model
-        self._tasks_data: BaseStore = RedisStore(redis_settings, redis_namespace)
+        self._tasks_data: BaseStore = RedisStore(redis_settings, lrt_namespace)
         self._created_tasks: dict[TaskId, asyncio.Task] = {}
 
         self.stale_task_check_interval = stale_task_check_interval
         self.stale_task_detect_timeout_s: PositiveFloat = (
             stale_task_detect_timeout.total_seconds()
         )
-        self.redis_namespace = redis_namespace
+        self.lrt_namespace = lrt_namespace
         self.redis_settings = redis_settings
 
         self.locks_redis_client_sdk: RedisClientSDK | None = None
@@ -151,15 +151,15 @@ async def setup(self) -> None:
 
         self.locks_redis_client_sdk = RedisClientSDK(
             self.redis_settings.build_redis_dsn(RedisDatabase.LOCKS),
-            client_name=f"long_running_tasks_store_{self.redis_namespace}_lock",
+            client_name=f"{__name__}_{self.lrt_namespace}_lock",
         )
         await self.locks_redis_client_sdk.setup()
 
         # stale_tasks_monitor
         self._task_stale_tasks_monitor = create_periodic_task(
             task=exclusive(
                 self.locks_redis_client_sdk,
-                lock_key=f"{__name__}_{self.redis_namespace}_stale_tasks_monitor",
+                lock_key=f"{__name__}_{self.lrt_namespace}_stale_tasks_monitor",
             )(self._stale_tasks_monitor),
             interval=self.stale_task_check_interval,
             task_name=f"{__name__}.{self._stale_tasks_monitor.__name__}",
@@ -437,8 +437,8 @@ async def remove_task(
                     pass
 
     def _get_task_id(self, task_name: str, *, is_unique: bool) -> TaskId:
-        unique_part = "unique" if is_unique else f"{uuid4()}"
-        return f"{self.redis_namespace}.{task_name}.{unique_part}"
+        id_part = "unique" if is_unique else f"{uuid4()}"
+        return f"{self.lrt_namespace}.{task_name}.{id_part}"
 
     async def _update_progress(
         self,

packages/service-library/tests/aiohttp/long_running_tasks/test_long_running_tasks.py

@@ -48,9 +48,8 @@ def app(
     long_running_tasks.server.setup(
         app,
         redis_settings=use_in_memory_redis,
-        redis_namespace="test",
         rabbit_settings=rabbit_service,
-        rabbit_namespace="test",
+        lrt_namespace="test",
         router_prefix="/futures",
     )
 

packages/service-library/tests/aiohttp/long_running_tasks/test_long_running_tasks_client.py

@@ -37,9 +37,8 @@ def app(
     long_running_tasks.server.setup(
         app,
         redis_settings=use_in_memory_redis,
-        redis_namespace="test",
         rabbit_settings=rabbit_service,
-        rabbit_namespace="test",
+        lrt_namespace="test",
         router_prefix="/futures",
     )