data-syncmaster 0.1.1__py3-none-any.whl

syncmaster/db/repositories/queue.py

@@ -0,0 +1,195 @@
+# SPDX-FileCopyrightText: 2023-2024 MTS (Mobile Telesystems)
+# SPDX-License-Identifier: Apache-2.0
+from typing import NoReturn
+
+from sqlalchemy import ScalarResult, insert, select
+from sqlalchemy.exc import DBAPIError, IntegrityError, NoResultFound
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from syncmaster.db.models import Group, GroupMemberRole, Queue, User, UserGroup
+from syncmaster.db.repositories.repository_with_owner import RepositoryWithOwner
+from syncmaster.db.utils import Permission
+from syncmaster.exceptions import EntityNotFoundError, SyncmasterError
+from syncmaster.exceptions.group import GroupNotFoundError
+from syncmaster.exceptions.queue import QueueNotFoundError
+
+# TODO: remove HTTP response schemes from repositories, these are different layers
+from syncmaster.schemas.v1.queue import UpdateQueueSchema
+
+
+class QueueRepository(RepositoryWithOwner[Queue]):
+    def __init__(self, session: AsyncSession):
+        super().__init__(model=Queue, session=session)
+
+    async def create(self, queue_data: dict) -> Queue:
+        query = insert(Queue).values(**queue_data).returning(Queue)
+        try:
+            result: ScalarResult[Queue] = await self._session.scalars(query)
+        except IntegrityError as e:
+            self._raise_error(e)
+        else:
+            await self._session.flush()
+            return result.one()
+
+    async def read_by_id(
+        self,
+        queue_id: int,
+    ) -> Queue:
+        stmt = (
+            select(Queue)
+            .where(Queue.id == queue_id, Queue.is_deleted.is_(False))
+            .options(selectinload(Queue.transfers))
+            .options(selectinload(Queue.group))
+        )
+        try:
+            result: ScalarResult[Queue] = await self._session.scalars(stmt)
+            return result.one()
+        except NoResultFound as e:
+            raise QueueNotFoundError from e
+
+    async def paginate(
+        self,
+        page: int,
+        page_size: int,
+        group_id: int,
+    ):
+        stmt = select(Queue).where(
+            Queue.is_deleted.is_(False),
+            Queue.group_id == group_id,
+        )
+        return await self._paginate_scalar_result(
+            query=stmt.order_by(Queue.id),
+            page=page,
+            page_size=page_size,
+        )
+
+    async def update(
+        self,
+        queue_id: int,
+        queue_data: UpdateQueueSchema,
+    ) -> Queue:
+        try:
+            queue = await self.read_by_id(queue_id=queue_id)
+            return await self._update(
+                Queue.id == queue_id,
+                Queue.is_deleted.is_(False),
+                description=queue_data.description or queue.description,
+            )
+        except IntegrityError as e:
+            self._raise_error(e)
+
+    async def delete(
+        self,
+        queue_id: int,
+    ) -> None:
+        try:
+            await self._delete(queue_id)
+        except (NoResultFound, EntityNotFoundError) as e:
+            raise QueueNotFoundError from e
+
+    async def get_group_permission(self, user: User, group_id: int) -> Permission:
+        """
+        Method for determining CRUD permissions in the specified group
+        'DEVELOPER' does not have WRITE permission in the QUEUE repository
+        """
+
+        owner_query = (
+            (
+                select(Group).where(
+                    Group.owner_id == user.id,
+                    Group.id == group_id,
+                )
+            )
+            .exists()
+            .select()
+        )
+
+        is_owner = await self._session.scalar(owner_query)
+
+        if is_owner:
+            return Permission.DELETE
+
+        group_role_query = select(UserGroup).where(
+            UserGroup.group_id == group_id,
+            UserGroup.user_id == user.id,
+        )
+
+        user_group = await self._session.scalar(group_role_query)
+
+        if not user_group:
+            # Check: group exists
+            if not await self._session.get(Group, group_id):
+                raise GroupNotFoundError
+
+            # If the user is not in the group, then he is either a superuser or does not have any rights
+            if not user.is_superuser:
+                return Permission.NONE
+            else:
+                return Permission.DELETE
+
+        group_role = user_group.role
+
+        if group_role in (GroupMemberRole.Guest, GroupMemberRole.Developer):
+            return Permission.READ
+
+        return Permission.DELETE
+
+    async def get_resource_permission(self, user: User, resource_id: int) -> Permission:
+        """
+        Method for determining CRUD rights in a repository (self.model) for a resource
+        'DEVELOPER' does not have WRITE permission in the QUEUE repository
+        """
+        is_exists = await self._session.get(self._model, resource_id)
+
+        if not is_exists:
+            return Permission.NONE
+
+        if user.is_superuser:
+            return Permission.DELETE
+
+        owner_query = (
+            (
+                select(self._model)
+                .join(
+                    Group,
+                    Group.id == self._model.group_id,
+                )
+                .where(
+                    Group.owner_id == user.id,
+                    self._model.id == resource_id,
+                )
+            )
+            .exists()
+            .select()
+        )
+
+        is_owner = await self._session.scalar(owner_query)
+
+        if is_owner:
+            return Permission.DELETE
+
+        group_role_query = (
+            select(UserGroup)
+            .join(
+                self._model,
+                UserGroup.group_id == self._model.group_id,
+            )
+            .where(self._model.id == resource_id, UserGroup.user_id == user.id)
+        )
+
+        user_group = await self._session.scalar(group_role_query)
+
+        if not user_group:
+            return Permission.NONE
+
+        group_role = user_group.role
+
+        if group_role in (GroupMemberRole.Guest, GroupMemberRole.Developer):
+            return Permission.READ
+
+        return Permission.DELETE
+
+    @staticmethod
+    def _raise_error(err: DBAPIError) -> NoReturn:
+        raise SyncmasterError from err

syncmaster/db/repositories/repository_with_owner.py

@@ -0,0 +1,115 @@
+# SPDX-FileCopyrightText: 2023-2024 MTS (Mobile Telesystems)
+# SPDX-License-Identifier: Apache-2.0
+from typing import Generic, TypeVar
+
+from sqlalchemy import select
+
+from syncmaster.db.models import Base, Group, GroupMemberRole, User, UserGroup
+from syncmaster.db.repositories.base import Repository
+from syncmaster.db.utils import Permission
+from syncmaster.exceptions.group import GroupNotFoundError
+
+Model = TypeVar("Model", bound=Base)
+
+
+class RepositoryWithOwner(Repository, Generic[Model]):
+    async def get_resource_permission(self, user: User, resource_id: int) -> Permission:
+        """Method for determining CRUD rights in a repository (self.model) for a resource"""
+        is_exists = await self._session.get(self._model, resource_id)
+
+        if not is_exists:
+            return Permission.NONE
+
+        if user.is_superuser:
+            return Permission.DELETE
+
+        owner_query = (
+            (
+                select(self._model)
+                .join(
+                    Group,
+                    Group.id == self._model.group_id,
+                )
+                .where(
+                    Group.owner_id == user.id,
+                    self._model.id == resource_id,
+                )
+            )
+            .exists()
+            .select()
+        )
+
+        is_owner = await self._session.scalar(owner_query)
+
+        if is_owner:
+            return Permission.DELETE
+
+        group_role_query = (
+            select(UserGroup)
+            .join(
+                self._model,
+                UserGroup.group_id == self._model.group_id,
+            )
+            .where(self._model.id == resource_id, UserGroup.user_id == user.id)
+        )
+
+        user_group = await self._session.scalar(group_role_query)
+
+        if not user_group:
+            return Permission.NONE
+
+        group_role = user_group.role
+
+        if group_role == GroupMemberRole.Guest:
+            return Permission.READ
+
+        if group_role == GroupMemberRole.Developer:
+            return Permission.WRITE
+
+        return Permission.DELETE  # Maintainer
+
+    async def get_group_permission(self, user: User, group_id: int) -> Permission:
+        """Method for determining CRUD permissions in the specified group"""
+        owner_query = (
+            (
+                select(Group).where(
+                    Group.owner_id == user.id,
+                    Group.id == group_id,
+                )
+            )
+            .exists()
+            .select()
+        )
+
+        is_owner = await self._session.scalar(owner_query)
+
+        if is_owner:
+            return Permission.DELETE
+
+        group_role_query = select(UserGroup).where(
+            UserGroup.group_id == group_id,
+            UserGroup.user_id == user.id,
+        )
+
+        user_group = await self._session.scalar(group_role_query)
+
+        if not user_group:
+            # Check: group exists
+            if not await self._session.get(Group, group_id):
+                raise GroupNotFoundError
+
+            # If the user is not in the group, then he is either a superuser or does not have any rights
+            if not user.is_superuser:
+                return Permission.NONE
+            else:
+                return Permission.DELETE
+
+        group_role = user_group.role
+
+        if group_role == GroupMemberRole.Guest:
+            return Permission.READ
+
+        if group_role == GroupMemberRole.Developer:
+            return Permission.WRITE
+
+        return Permission.DELETE  # Maintainer

syncmaster/db/repositories/run.py

@@ -0,0 +1,78 @@
+# SPDX-FileCopyrightText: 2023-2024 MTS (Mobile Telesystems)
+# SPDX-License-Identifier: Apache-2.0
+from typing import Any, NoReturn
+
+from sqlalchemy import desc, select
+from sqlalchemy.exc import DBAPIError, IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from syncmaster.db.models import Run, Status, Transfer
+from syncmaster.db.repositories.base import Repository
+from syncmaster.db.utils import Pagination
+from syncmaster.exceptions import SyncmasterError
+from syncmaster.exceptions.run import CannotStopRunError, RunNotFoundError
+from syncmaster.exceptions.transfer import TransferNotFoundError
+from syncmaster.schemas.v1.transfers import ReadFullTransferSchema
+
+
+class RunRepository(Repository[Run]):
+    def __init__(self, session: AsyncSession) -> None:
+        super().__init__(model=Run, session=session)
+
+    async def paginate(
+        self,
+        transfer_id: int,
+        page: int,
+        page_size: int,
+    ) -> Pagination:
+        query = select(Run).where(Run.transfer_id == transfer_id).order_by(desc(Run.created_at))
+        return await self._paginate_scalar_result(query=query, page=page, page_size=page_size)
+
+    async def read_by_id(self, run_id: int) -> Run:
+        run = await self._session.get(Run, run_id)
+        if run is None:
+            raise RunNotFoundError
+        return run
+
+    async def create(self, transfer_id: int) -> Run:
+        run = Run()
+        run.transfer_id = transfer_id
+        run.transfer_dump = await self.read_full_serialized_transfer(transfer_id)
+        try:
+            self._session.add(run)
+            await self._session.flush()
+            return run
+        except IntegrityError as e:
+            self._raise_error(e)
+
+    async def update(self, run_id: int, **kwargs: Any) -> Run:
+        try:
+            return await self._update(Run.id == run_id, **kwargs)
+        except IntegrityError as e:
+            self._raise_error(e)
+
+    async def stop(self, run_id: int) -> Run:
+        run = await self.read_by_id(run_id=run_id)
+        if run.status not in [Status.CREATED, Status.STARTED]:
+            raise CannotStopRunError(run_id=run_id, current_status=run.status)
+        run.status = Status.SEND_STOP_SIGNAL
+        await self._session.flush()
+        return run
+
+    async def read_full_serialized_transfer(self, transfer_id: int) -> dict[str, Any]:
+        transfer = await self._session.scalars(
+            select(Transfer)
+            .where(Transfer.id == transfer_id)
+            .options(
+                selectinload(Transfer.source_connection),
+                selectinload(Transfer.target_connection),
+            )
+        )
+        return ReadFullTransferSchema.from_orm(transfer.one()).dict()
+
+    def _raise_error(self, e: DBAPIError) -> NoReturn:
+        constraint = e.__cause__.__cause__.constraint_name
+        if constraint == "fk__run__transfer_id__transfer":
+            raise TransferNotFoundError from e
+        raise SyncmasterError from e

syncmaster/db/repositories/transfer.py

@@ -0,0 +1,202 @@
+# SPDX-FileCopyrightText: 2023-2024 MTS (Mobile Telesystems)
+# SPDX-License-Identifier: Apache-2.0
+from collections.abc import Sequence
+from typing import Any, NoReturn
+
+from sqlalchemy import ScalarResult, insert, or_, select
+from sqlalchemy.exc import DBAPIError, IntegrityError, NoResultFound
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from syncmaster.db.models import Transfer
+from syncmaster.db.repositories.repository_with_owner import RepositoryWithOwner
+from syncmaster.db.utils import Pagination
+from syncmaster.exceptions import EntityNotFoundError, SyncmasterError
+from syncmaster.exceptions.connection import ConnectionNotFoundError
+from syncmaster.exceptions.group import GroupNotFoundError
+from syncmaster.exceptions.queue import QueueNotFoundError
+from syncmaster.exceptions.transfer import (
+    DuplicatedTransferNameError,
+    TransferNotFoundError,
+    TransferOwnerError,
+)
+from syncmaster.exceptions.user import UserNotFoundError
+
+
+class TransferRepository(RepositoryWithOwner[Transfer]):
+    def __init__(self, session: AsyncSession):
+        super().__init__(model=Transfer, session=session)
+
+    async def paginate(
+        self,
+        page: int,
+        page_size: int,
+        group_id: int | None = None,
+    ) -> Pagination:
+        stmt = select(Transfer).where(Transfer.is_deleted.is_(False))
+
+        return await self._paginate_scalar_result(
+            query=stmt.where(Transfer.group_id == group_id).order_by(Transfer.name),
+            page=page,
+            page_size=page_size,
+        )
+
+    async def read_by_id(
+        self,
+        transfer_id: int,
+    ) -> Transfer:
+        stmt = (
+            select(Transfer)
+            .where(
+                Transfer.id == transfer_id,
+                Transfer.is_deleted.is_(False),
+            )
+            .options(selectinload(Transfer.queue))
+        )
+        try:
+            result: ScalarResult[Transfer] = await self._session.scalars(stmt)
+            return result.one()
+        except NoResultFound as e:
+            raise TransferNotFoundError from e
+
+    async def create(
+        self,
+        group_id: int,
+        source_connection_id: int,
+        target_connection_id: int,
+        name: str,
+        description: str,
+        source_params: dict[str, Any],
+        target_params: dict[str, Any],
+        strategy_params: dict[str, Any],
+        queue_id: int,
+    ) -> Transfer:
+        query = (
+            insert(Transfer)
+            .values(
+                group_id=group_id,
+                source_connection_id=source_connection_id,
+                target_connection_id=target_connection_id,
+                name=name,
+                description=description,
+                source_params=source_params,
+                target_params=target_params,
+                strategy_params=strategy_params,
+                queue_id=queue_id,
+            )
+            .returning(Transfer)
+        )
+        try:
+            result: ScalarResult[Transfer] = await self._session.scalars(query)
+        except IntegrityError as e:
+            self._raise_error(e)
+        else:
+            await self._session.flush()
+            return result.one()
+
+    async def update(
+        self,
+        transfer: Transfer,
+        name: str | None,
+        description: str | None,
+        source_connection_id: int | None,
+        target_connection_id: int | None,
+        source_params: dict[str, Any],
+        target_params: dict[str, Any],
+        strategy_params: dict[str, Any],
+        is_scheduled: bool | None,
+        schedule: str | None,
+        new_queue_id: int | None,
+    ) -> Transfer:
+        try:
+            for key in transfer.source_params:
+                if key not in source_params or source_params[key] is None:
+                    source_params[key] = transfer.source_params[key]
+            for key in transfer.target_params:
+                if key not in target_params or target_params[key] is None:
+                    target_params[key] = transfer.target_params[key]
+            for key in transfer.strategy_params:
+                if key not in strategy_params or strategy_params[key] is None:
+                    strategy_params[key] = transfer.strategy_params[key]
+            return await self._update(
+                Transfer.id == transfer.id,
+                Transfer.is_deleted.is_(False),
+                name=name or transfer.name,
+                description=description or transfer.description,
+                strategy_params=strategy_params,
+                is_scheduled=is_scheduled or transfer.is_scheduled,
+                schedule=schedule or transfer.schedule,
+                source_connection_id=source_connection_id or transfer.source_connection_id,
+                target_connection_id=target_connection_id or transfer.target_connection_id,
+                source_params=source_params,
+                target_params=target_params,
+                queue_id=new_queue_id or transfer.queue_id,
+            )
+        except IntegrityError as e:
+            self._raise_error(e)
+
+    async def delete(
+        self,
+        transfer_id: int,
+    ) -> None:
+        try:
+            await self._delete(transfer_id)
+        except (NoResultFound, EntityNotFoundError) as e:
+            raise TransferNotFoundError from e
+
+    async def copy(
+        self,
+        transfer_id: int,
+        new_queue_id: int,
+        new_group_id: int | None,
+        new_source_connection: int | None,
+        new_target_connection: int | None,
+        new_name: str | None,
+    ) -> Transfer:
+        try:
+            kwargs = dict(
+                group_id=new_group_id,
+                source_connection_id=new_source_connection,
+                target_connection_id=new_target_connection,
+                queue_id=new_queue_id,
+                name=new_name,
+            )
+            new_transfer = await self._copy(Transfer.id == transfer_id, **kwargs)
+
+            return new_transfer
+        except IntegrityError as integrity_error:
+            self._raise_error(integrity_error)
+
+    async def list_by_connection_id(self, conn_id: int) -> Sequence[Transfer]:
+        query = select(Transfer).where(
+            or_(
+                Transfer.source_connection_id == conn_id,
+                Transfer.target_connection_id == conn_id,
+            )
+        )
+        result = await self._session.scalars(query)
+        return result.fetchall()
+
+    def _raise_error(self, err: DBAPIError) -> NoReturn:
+        constraint = err.__cause__.__cause__.constraint_name
+        if constraint == "fk__transfer__group_id__group":
+            raise GroupNotFoundError from err
+        if constraint == "fk__transfer__user_id__user":
+            raise UserNotFoundError from err
+
+        if constraint in [
+            "fk__transfer__source_connection_id__connection",
+            "fk__transfer__target_connection_id__connection",
+        ]:
+            raise ConnectionNotFoundError from err
+
+        if constraint == "ck__transfer__owner_constraint":
+            raise TransferOwnerError from err
+
+        if constraint == "fk__transfer__queue_id__queue":
+            raise QueueNotFoundError from err
+
+        if constraint == "uq__transfer__name_group_id":
+            raise DuplicatedTransferNameError
+
+        raise SyncmasterError from err

syncmaster/db/repositories/user.py

@@ -0,0 +1,72 @@
+# SPDX-FileCopyrightText: 2023-2024 MTS (Mobile Telesystems)
+# SPDX-License-Identifier: Apache-2.0
+from typing import Any, NoReturn
+
+from sqlalchemy import ScalarResult, insert, select
+from sqlalchemy.exc import DBAPIError, IntegrityError, NoResultFound
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from syncmaster.db.models import User
+from syncmaster.db.repositories.base import Repository
+from syncmaster.db.utils import Pagination
+from syncmaster.exceptions import EntityNotFoundError, SyncmasterError
+from syncmaster.exceptions.user import UsernameAlreadyExistsError, UserNotFoundError
+
+
+class UserRepository(Repository[User]):
+    def __init__(self, session: AsyncSession) -> None:
+        super().__init__(model=User, session=session)
+
+    async def paginate(self, page: int, page_size: int, is_superuser: bool) -> Pagination:
+        stmt = select(User).where(User.is_deleted.is_(False))
+
+        if not is_superuser:
+            stmt = stmt.where(User.is_active.is_(True))
+        return await self._paginate_scalar_result(query=stmt.order_by(User.username), page=page, page_size=page_size)
+
+    async def read_by_id(self, user_id: int, **kwargs: Any) -> User:
+        try:
+            return await self._read_by_id(id=user_id, **kwargs)
+        except EntityNotFoundError as e:
+            raise UserNotFoundError from e
+
+    async def read_by_username(self, username: str) -> User:
+        try:
+            result: ScalarResult[User] = await self._session.scalars(select(User).where(User.username == username))
+            return result.one()
+        except NoResultFound as e:
+            raise EntityNotFoundError from e
+
+    async def update(self, user_id: int, data: dict) -> User:
+        try:
+            return await self._update(User.id == user_id, User.is_deleted.is_(False), **data)
+        except EntityNotFoundError as e:
+            raise UserNotFoundError from e
+        except IntegrityError as e:
+            self._raise_error(e)
+
+    async def create(self, username: str, is_active: bool, is_superuser: bool = False) -> User:
+        query = (
+            insert(User)
+            .values(
+                username=username,
+                is_active=is_active,
+                is_superuser=is_superuser,
+            )
+            .returning(User)
+        )
+        try:
+            result: ScalarResult[User] = await self._session.scalars(query)
+            await self._session.flush()
+        except IntegrityError as err:
+            self._raise_error(err)
+        else:
+            return result.one()
+
+    def _raise_error(self, err: DBAPIError) -> NoReturn:
+        constraint = err.__cause__.__cause__.constraint_name
+
+        if constraint == "ix__user__username":
+            raise UsernameAlreadyExistsError from err
+
+        raise SyncmasterError from err

syncmaster/db/repositories/utils.py

@@ -0,0 +1,25 @@
+# SPDX-FileCopyrightText: 2023-2024 MTS (Mobile Telesystems)
+# SPDX-License-Identifier: Apache-2.0
+import json
+
+from cryptography.fernet import Fernet
+
+from syncmaster.config import Settings
+
+
+def decrypt_auth_data(
+    value: str,
+    settings: Settings,
+) -> dict:
+    f = Fernet(settings.CRYPTO_KEY)
+    return json.loads(f.decrypt(value))
+
+
+def encrypt_auth_data(
+    value: dict,
+    settings: Settings,
+) -> str:
+    key = str.encode(settings.CRYPTO_KEY)
+    f = Fernet(key)
+    token = f.encrypt(str.encode(json.dumps(value)))
+    return token.decode(encoding="utf-8")