python3-cyberfusion-queue-support 1.1.3__py3-none-any.whl

cyberfusion/QueueSupport/__init__.py

@@ -0,0 +1,72 @@
+"""Classes for queue."""
+
+import logging
+from typing import List
+
+from cyberfusion.QueueSupport.exceptions import QueueFulfillFailed
+from cyberfusion.QueueSupport.interfaces import OutcomeInterface
+from cyberfusion.QueueSupport.items import _Item
+
+logger = logging.getLogger(__name__)
+
+
+class Queue:
+    """Represents queue."""
+
+    def __init__(self) -> None:
+        """Set attributes."""
+        self.items: List[_Item] = []
+
+    def add(self, item: _Item, *, move_duplicate_last: bool = True) -> None:
+        """Add item to queue."""
+        if item not in self.items:
+            self.items.append(item)
+
+            logger.info("Added item to queue (reference: '%s')", item.reference)
+        else:
+            # If item already in queue, move to last place
+
+            if move_duplicate_last:
+                self.items.append(self.items.pop(self.items.index(item)))
+
+                logger.info(
+                    "Added item to queue (reference: '%s') (moving duplicate last)",
+                    item.reference,
+                )
+            else:
+                logger.info(
+                    "Didn't add item to queue (reference: '%s') (already present)",
+                    item.reference,
+                )
+
+    def process(self, preview: bool) -> List[OutcomeInterface]:
+        """Process items."""
+        logger.info("Processing items")
+
+        results = []
+
+        for item in self.items:
+            logger.info("Processing item '%s'", item.reference)
+
+            if not item.hide_outcomes:
+                results.extend(item.outcomes)
+
+            if not preview:
+                try:
+                    logger.info("Fulfilling item '%s'", item.reference)
+
+                    item.fulfill()
+
+                    logger.info("Fulfilled item '%s'", item.reference)
+                except QueueFulfillFailed:
+                    raise
+                except Exception as e:
+                    raise QueueFulfillFailed(
+                        item,
+                    ) from e
+
+            logger.info("Processed item '%s'", item.reference)
+
+        logger.info("Processed items")
+
+        return results

cyberfusion/QueueSupport/exceptions/__init__.py

@@ -0,0 +1,39 @@
+"""Exceptions."""
+
+from dataclasses import dataclass
+from typing import List
+
+from cyberfusion.QueueSupport.items import _Item
+
+
+class ItemError(Exception):
+    """Issues with item."""
+
+    pass
+
+
+@dataclass
+class PathIsSymlinkError(ItemError):
+    """Path is symlink."""
+
+    path: str
+
+
+@dataclass
+class QueueFulfillFailed(Exception):
+    """Error occurred while fulfilling queue."""
+
+    item: _Item
+
+
+@dataclass
+class CommandQueueFulfillFailed(QueueFulfillFailed):
+    """Error occurred while fulfilling queue, with command item."""
+
+    command: List[str]
+    stdout: str
+    stderr: str
+
+    def __str__(self) -> str:
+        """Get string representation."""
+        return f"Command:\n\n{self.command}\n\nStdout:\n\n{self.stdout}\n\nStderr:\n\n{self.stderr}"

cyberfusion/QueueSupport/interfaces.py

@@ -0,0 +1,38 @@
+"""Interfaces."""
+
+from abc import ABCMeta, abstractmethod
+from typing import List
+
+
+class OutcomeInterface(metaclass=ABCMeta):
+    """Interface for outcomes."""
+
+    @abstractmethod
+    def __str__(self) -> str:  # pragma: no cover
+        """Get human-readable string."""
+        pass
+
+    @abstractmethod
+    def __eq__(self, other: object) -> bool:  # pragma: no cover
+        """Get equality based on attributes."""
+        pass
+
+
+class ItemInterface(metaclass=ABCMeta):
+    """Interface for items."""
+
+    @property
+    @abstractmethod
+    def outcomes(self) -> List[OutcomeInterface]:  # pragma: no cover
+        """Get outcomes of calling self.fulfill."""
+        pass
+
+    @abstractmethod
+    def fulfill(self) -> None:  # pragma: no cover
+        """Fulfill outcomes."""
+        pass
+
+    @abstractmethod
+    def __eq__(self, other: object) -> bool:  # pragma: no cover
+        """Get equality based on attributes."""
+        pass

cyberfusion/QueueSupport/items/__init__.py

@@ -0,0 +1,22 @@
+"""Items."""
+
+import logging
+from typing import Optional
+
+from cyberfusion.QueueSupport.interfaces import ItemInterface
+
+logger = logging.getLogger(__name__)
+
+
+class _Item(ItemInterface):
+    """Represents base item."""
+
+    @property
+    def hide_outcomes(self) -> bool:
+        """Get if outcomes should be hidden."""
+        return self._hide_outcomes
+
+    @property
+    def reference(self) -> Optional[str]:
+        """Get free-form reference, for users' own administrations."""
+        return self._reference

cyberfusion/QueueSupport/items/chmod.py

@@ -0,0 +1,74 @@
+"""Item."""
+
+import logging
+import os
+from typing import List, Optional
+
+from cyberfusion.QueueSupport.exceptions import PathIsSymlinkError
+from cyberfusion.QueueSupport.interfaces import OutcomeInterface
+from cyberfusion.QueueSupport.items import _Item
+from cyberfusion.QueueSupport.outcomes import ChmodItemModeChangeOutcome
+from cyberfusion.QueueSupport.utilities import get_decimal_permissions
+
+logger = logging.getLogger(__name__)
+
+
+class ChmodItem(_Item):
+    """Represents item."""
+
+    def __init__(
+        self,
+        *,
+        path: str,
+        mode: int,
+        reference: Optional[str] = None,
+        hide_outcomes: bool = False,
+    ) -> None:
+        """Set attributes."""
+        self.path = path
+        self.mode = mode
+        self._reference = reference
+        self._hide_outcomes = hide_outcomes
+
+        if os.path.islink(self.path):
+            raise PathIsSymlinkError(self.path)
+
+    @property
+    def outcomes(self) -> List[OutcomeInterface]:
+        """Get outcomes of calling self.fulfill."""
+        outcomes = []
+
+        if not os.path.exists(self.path):
+            outcomes.append(
+                ChmodItemModeChangeOutcome(
+                    path=self.path, old_mode=None, new_mode=self.mode
+                )
+            )
+        else:
+            old_mode = get_decimal_permissions(self.path)
+            mode_changed = old_mode != self.mode
+
+            if mode_changed:
+                outcomes.append(
+                    ChmodItemModeChangeOutcome(
+                        path=self.path, old_mode=old_mode, new_mode=self.mode
+                    )
+                )
+
+        return outcomes
+
+    def fulfill(self) -> None:
+        """Fulfill outcomes."""
+        mode_change_outcomes = [
+            x for x in self.outcomes if isinstance(x, ChmodItemModeChangeOutcome)
+        ]
+
+        if mode_change_outcomes:
+            os.chmod(mode_change_outcomes[0].path, mode_change_outcomes[0].new_mode)
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, ChmodItem):
+            return False
+
+        return other.path == self.path and other.mode == self.mode

cyberfusion/QueueSupport/items/chown.py

@@ -0,0 +1,140 @@
+"""Item."""
+
+import grp
+import logging
+import os
+import pwd
+from grp import getgrgid
+from pwd import getpwuid
+from typing import List, Optional
+
+from cyberfusion.QueueSupport.exceptions import PathIsSymlinkError
+from cyberfusion.QueueSupport.interfaces import OutcomeInterface
+from cyberfusion.QueueSupport.items import _Item
+from cyberfusion.QueueSupport.outcomes import (
+    ChownItemGroupChangeOutcome,
+    ChownItemOwnerChangeOutcome,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def get_uid(username: str) -> int:
+    """Get UID by username."""
+    return pwd.getpwnam(username).pw_uid
+
+
+def get_gid(group_name: str) -> int:
+    """Get GID by group name."""
+    return grp.getgrnam(group_name).gr_gid
+
+
+class ChownItem(_Item):
+    """Represents item."""
+
+    def __init__(
+        self,
+        *,
+        path: str,
+        owner_name: str,
+        group_name: str,
+        reference: Optional[str] = None,
+        hide_outcomes: bool = False,
+    ) -> None:
+        """Set attributes."""
+        self.path = path
+        self.owner_name = owner_name
+        self.group_name = group_name
+        self._reference = reference
+        self._hide_outcomes = hide_outcomes
+
+        if os.path.islink(self.path):
+            raise PathIsSymlinkError(self.path)
+
+    @property
+    def outcomes(self) -> List[OutcomeInterface]:
+        """Get outcomes of calling self.fulfill."""
+        outcomes = []
+
+        if not os.path.exists(self.path):
+            outcomes.extend(
+                [
+                    ChownItemOwnerChangeOutcome(
+                        path=self.path,
+                        old_owner_name=None,
+                        new_owner_name=self.owner_name,
+                    ),
+                    ChownItemGroupChangeOutcome(
+                        path=self.path,
+                        old_group_name=None,
+                        new_group_name=self.group_name,
+                    ),
+                ]
+            )
+        else:
+            try:
+                old_owner_name = getpwuid(os.stat(self.path).st_uid).pw_name
+            except KeyError:
+                old_owner_name = "(no user with UID exists)"
+
+            try:
+                old_group_name = getgrgid(os.stat(self.path).st_gid).gr_name
+            except KeyError:
+                old_group_name = "(no group with GID exists)"
+
+            owner_name_changed = old_owner_name != self.owner_name
+            group_name_changed = old_group_name != self.group_name
+
+            if owner_name_changed:
+                outcomes.append(
+                    ChownItemOwnerChangeOutcome(
+                        path=self.path,
+                        old_owner_name=old_owner_name,
+                        new_owner_name=self.owner_name,
+                    )
+                )
+
+            if group_name_changed:
+                outcomes.append(
+                    ChownItemGroupChangeOutcome(
+                        path=self.path,
+                        old_group_name=old_group_name,
+                        new_group_name=self.group_name,
+                    )
+                )
+
+        return outcomes
+
+    def fulfill(self) -> None:
+        """Fulfill outcomes."""
+        owner_name_change_outcomes = [
+            x for x in self.outcomes if isinstance(x, ChownItemOwnerChangeOutcome)
+        ]
+        group_name_change_outcomes = [
+            x for x in self.outcomes if isinstance(x, ChownItemGroupChangeOutcome)
+        ]
+
+        if owner_name_change_outcomes:
+            os.chown(
+                owner_name_change_outcomes[0].path,
+                uid=get_uid(owner_name_change_outcomes[0].new_owner_name),
+                gid=-1,
+            )
+
+        if group_name_change_outcomes:
+            os.chown(
+                group_name_change_outcomes[0].path,
+                uid=-1,
+                gid=get_gid(group_name_change_outcomes[0].new_group_name),
+            )
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, ChownItem):
+            return False
+
+        return (
+            other.path == self.path
+            and other.owner_name == self.owner_name
+            and other.group_name == self.group_name
+        )

cyberfusion/QueueSupport/items/command.py

@@ -0,0 +1,67 @@
+"""Item."""
+
+import logging
+import subprocess
+from typing import List, Optional
+
+from cyberfusion.QueueSupport.exceptions import CommandQueueFulfillFailed
+from cyberfusion.QueueSupport.interfaces import OutcomeInterface
+from cyberfusion.QueueSupport.items import _Item
+from cyberfusion.QueueSupport.outcomes import CommandItemRunOutcome
+
+logger = logging.getLogger(__name__)
+
+
+class CommandItem(_Item):
+    """Represents item."""
+
+    def __init__(
+        self,
+        *,
+        command: List[str],
+        reference: Optional[str] = None,
+        hide_outcomes: bool = False,
+    ) -> None:
+        """Set attributes."""
+        self.command = command
+        self._reference = reference
+        self._hide_outcomes = hide_outcomes
+
+    @property
+    def outcomes(self) -> List[OutcomeInterface]:
+        """Get outcomes of calling self.fulfill."""
+        outcomes = []
+
+        outcomes.append(CommandItemRunOutcome(command=self.command))
+
+        return outcomes
+
+    def fulfill(self) -> None:
+        """Fulfill outcomes."""
+        run_outcomes = [
+            x for x in self.outcomes if isinstance(x, CommandItemRunOutcome)
+        ]
+
+        command = run_outcomes[0].command
+
+        try:
+            output = subprocess.run(
+                command,
+                check=True,
+                text=True,
+                capture_output=True,
+            )
+
+            logger.info("Command stdout: %s", output.stdout)
+            logger.info("Command stderr: %s", output.stderr)
+        except subprocess.CalledProcessError as e:
+            raise CommandQueueFulfillFailed(
+                self, command=command, stdout=e.stdout, stderr=e.stderr
+            ) from e
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, CommandItem):
+            return False
+
+        return other.command == self.command

cyberfusion/QueueSupport/items/copy.py

@@ -0,0 +1,61 @@
+"""Item."""
+
+import logging
+import os
+import shutil
+from typing import List, Optional
+
+from cyberfusion.QueueSupport.exceptions import PathIsSymlinkError
+from cyberfusion.QueueSupport.interfaces import OutcomeInterface
+from cyberfusion.QueueSupport.items import _Item
+from cyberfusion.QueueSupport.outcomes import CopyItemCopyOutcome
+
+logger = logging.getLogger(__name__)
+
+
+class CopyItem(_Item):
+    """Represents item."""
+
+    def __init__(
+        self,
+        *,
+        source: str,
+        destination: str,
+        reference: Optional[str] = None,
+        hide_outcomes: bool = False,
+    ) -> None:
+        """Set attributes."""
+        self.source = source
+        self.destination = destination
+        self._reference = reference
+        self._hide_outcomes = hide_outcomes
+
+        if os.path.islink(self.source):
+            raise PathIsSymlinkError(self.source)
+
+        if os.path.islink(self.destination):
+            raise PathIsSymlinkError(self.destination)
+
+    @property
+    def outcomes(self) -> List[OutcomeInterface]:
+        """Get outcomes of calling self.fulfill."""
+        outcomes = []
+
+        outcomes.append(
+            CopyItemCopyOutcome(source=self.source, destination=self.destination)
+        )
+
+        return outcomes
+
+    def fulfill(self) -> None:
+        """Fulfill outcomes."""
+        copy_outcomes = [x for x in self.outcomes if isinstance(x, CopyItemCopyOutcome)]
+
+        shutil.copyfile(copy_outcomes[0].source, copy_outcomes[0].destination)
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, CopyItem):
+            return False
+
+        return other.source == self.source and other.destination == self.destination

cyberfusion/QueueSupport/items/mkdir.py

@@ -0,0 +1,61 @@
+"""Item."""
+
+import logging
+import os
+from typing import List, Optional
+
+from cyberfusion.QueueSupport.exceptions import PathIsSymlinkError
+from cyberfusion.QueueSupport.interfaces import OutcomeInterface
+from cyberfusion.QueueSupport.items import _Item
+from cyberfusion.QueueSupport.outcomes import MkdirItemCreateOutcome
+
+logger = logging.getLogger(__name__)
+
+
+class MkdirItem(_Item):
+    """Represents item."""
+
+    def __init__(
+        self,
+        *,
+        path: str,
+        reference: Optional[str] = None,
+        hide_outcomes: bool = False,
+    ) -> None:
+        """Set attributes."""
+        self.path = path
+        self._reference = reference
+        self._hide_outcomes = hide_outcomes
+
+        if os.path.islink(self.path):
+            raise PathIsSymlinkError(self.path)
+
+    @property
+    def outcomes(self) -> List[OutcomeInterface]:
+        """Get outcomes of calling self.fulfill."""
+        outcomes = []
+
+        if not os.path.isdir(self.path):
+            outcomes.append(
+                MkdirItemCreateOutcome(
+                    path=self.path,
+                )
+            )
+
+        return outcomes
+
+    def fulfill(self) -> None:
+        """Fulfill outcomes."""
+        create_outcomes = [
+            x for x in self.outcomes if isinstance(x, MkdirItemCreateOutcome)
+        ]
+
+        if create_outcomes:
+            os.mkdir(create_outcomes[0].path)
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, MkdirItem):
+            return False
+
+        return other.path == self.path

cyberfusion/QueueSupport/items/move.py

@@ -0,0 +1,61 @@
+"""Item."""
+
+import logging
+import os
+import shutil
+from typing import List, Optional
+
+from cyberfusion.QueueSupport.exceptions import PathIsSymlinkError
+from cyberfusion.QueueSupport.interfaces import OutcomeInterface
+from cyberfusion.QueueSupport.items import _Item
+from cyberfusion.QueueSupport.outcomes import MoveItemMoveOutcome
+
+logger = logging.getLogger(__name__)
+
+
+class MoveItem(_Item):
+    """Represents item."""
+
+    def __init__(
+        self,
+        *,
+        source: str,
+        destination: str,
+        reference: Optional[str] = None,
+        hide_outcomes: bool = False,
+    ) -> None:
+        """Set attributes."""
+        self.source = source
+        self.destination = destination
+        self._reference = reference
+        self._hide_outcomes = hide_outcomes
+
+        if os.path.islink(self.source):
+            raise PathIsSymlinkError(self.source)
+
+        if os.path.islink(self.destination):
+            raise PathIsSymlinkError(self.destination)
+
+    @property
+    def outcomes(self) -> List[OutcomeInterface]:
+        """Get outcomes of calling self.fulfill."""
+        outcomes = []
+
+        outcomes.append(
+            MoveItemMoveOutcome(source=self.source, destination=self.destination)
+        )
+
+        return outcomes
+
+    def fulfill(self) -> None:
+        """Fulfill outcomes."""
+        move_outcomes = [x for x in self.outcomes if isinstance(x, MoveItemMoveOutcome)]
+
+        shutil.move(move_outcomes[0].source, move_outcomes[0].destination)
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, MoveItem):
+            return False
+
+        return other.source == self.source and other.destination == self.destination

cyberfusion/QueueSupport/items/systemd_tmp_files_create.py

@@ -0,0 +1,55 @@
+"""Item."""
+
+import logging
+from typing import List, Optional
+
+from cyberfusion.QueueSupport.interfaces import OutcomeInterface
+from cyberfusion.QueueSupport.items import _Item
+from cyberfusion.QueueSupport.outcomes import (
+    SystemdTmpFilesCreateItemCreateOutcome,
+)
+from cyberfusion.SystemdSupport.tmp_files import TmpFileConfigurationFile
+
+logger = logging.getLogger(__name__)
+
+
+class SystemdTmpFilesCreateItem(_Item):
+    """Represents item."""
+
+    def __init__(
+        self,
+        *,
+        path: str,
+        reference: Optional[str] = None,
+        hide_outcomes: bool = False,
+    ) -> None:
+        """Set attributes."""
+        self.path = path
+        self._reference = reference
+        self._hide_outcomes = hide_outcomes
+
+    @property
+    def outcomes(self) -> List[OutcomeInterface]:
+        """Get outcomes of calling self.fulfill."""
+        outcomes = []
+
+        outcomes.append(SystemdTmpFilesCreateItemCreateOutcome(path=self.path))
+
+        return outcomes
+
+    def fulfill(self) -> None:
+        """Fulfill outcomes."""
+        systemd_tmp_files_create_outcomes = [
+            x
+            for x in self.outcomes
+            if isinstance(x, SystemdTmpFilesCreateItemCreateOutcome)
+        ]
+
+        TmpFileConfigurationFile(systemd_tmp_files_create_outcomes[0].path).create()
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, SystemdTmpFilesCreateItem):
+            return False
+
+        return other.path == self.path