python3-cyberfusion-queue-support 1.1.1.1.3__tar.gz

python3-cyberfusion-queue-support-1.1.1.1.3/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.1
+Name: python3-cyberfusion-queue-support
+Version: 1.1.1.1.3
+Summary: Library to queue actions.
+Home-page: https://github.com/CyberfusionIO/python3-cyberfusion-queue-support
+Author: Cyberfusion
+Author-email: support@cyberfusion.io
+Platform: linux
+Description-Content-Type: text/markdown
+
+# python3-cyberfusion-queue-support
+
+Library to queue actions.
+
+# Install
+
+## PyPI
+
+Run the following command to install the package from PyPI:
+
+    pip3 install python3-cyberfusion-queue-support
+
+## Generic
+
+Run the following command to create a source distribution:
+
+    python3 setup.py sdist
+
+## Debian
+
+Run the following commands to build a Debian package:
+
+    mk-build-deps -i -t 'apt -o Debug::pkgProblemResolver=yes --no-install-recommends -y'
+    dpkg-buildpackage -us -uc
+
+# Configure
+
+No configuration is supported.
+
+# Usage
+
+## Example
+
+```python
+from cyberfusion.QueueSupport import Queue
+from cyberfusion.QueueSupport.items.chmod import ChmodItem
+
+queue = Queue()
+
+item = ChmodItem(path="/tmp/example.txt", mode=0o600)
+print(item.outcomes)
+
+queue.add(item)
+
+preview = True or False
+
+outcomes = queue.process(preview=preview)
+
+for outcome in outcomes:
+    print(str(outcome))
+```

python3-cyberfusion-queue-support-1.1.1.1.3/README.md

@@ -0,0 +1,51 @@
+# python3-cyberfusion-queue-support
+
+Library to queue actions.
+
+# Install
+
+## PyPI
+
+Run the following command to install the package from PyPI:
+
+    pip3 install python3-cyberfusion-queue-support
+
+## Generic
+
+Run the following command to create a source distribution:
+
+    python3 setup.py sdist
+
+## Debian
+
+Run the following commands to build a Debian package:
+
+    mk-build-deps -i -t 'apt -o Debug::pkgProblemResolver=yes --no-install-recommends -y'
+    dpkg-buildpackage -us -uc
+
+# Configure
+
+No configuration is supported.
+
+# Usage
+
+## Example
+
+```python
+from cyberfusion.QueueSupport import Queue
+from cyberfusion.QueueSupport.items.chmod import ChmodItem
+
+queue = Queue()
+
+item = ChmodItem(path="/tmp/example.txt", mode=0o600)
+print(item.outcomes)
+
+queue.add(item)
+
+preview = True or False
+
+outcomes = queue.process(preview=preview)
+
+for outcome in outcomes:
+    print(str(outcome))
+```

python3-cyberfusion-queue-support-1.1.1.1.3/pyproject.toml

@@ -0,0 +1,21 @@
+[tool.isort]
+profile = "black"
+line_length = 79
+known_first_party = ["cyberfusion"]
+default_section = "THIRDPARTY"
+
+[tool.black]
+line-length = 79
+exclude = '''
+(
+  /(
+      \.eggs         # exclude a few common directories in the
+    | \.git          # root of the project
+    | \.hg
+    | \.mypy_cache
+    | \.tox
+    | \.venv
+    | venv
+  )/
+)
+'''

python3-cyberfusion-queue-support-1.1.1.1.3/setup.cfg

@@ -0,0 +1,12 @@
+[aliases]
+test = pytest
+
+[tool:pytest]
+norecursedirs = .git build dist *.egg __pycache__ .cache
+testpaths = tests
+junit_suite_name = python3-cyberfusion-queue-support
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

python3-cyberfusion-queue-support-1.1.1.1.3/setup.py

@@ -0,0 +1,25 @@
+"""A setuptools based setup module."""
+
+from setuptools import setup
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="python3-cyberfusion-queue-support",
+    version="1.1.1.1.3",
+    description="Library to queue actions.",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author="Cyberfusion",
+    author_email="support@cyberfusion.io",
+    url="https://github.com/CyberfusionIO/python3-cyberfusion-queue-support",
+    platforms=["linux"],
+    packages=[
+        "cyberfusion.QueueSupport",
+        "cyberfusion.QueueSupport.items",
+        "cyberfusion.QueueSupport.exceptions",
+    ],
+    package_dir={"": "src"},
+    data_files=[],
+)

python3-cyberfusion-queue-support-1.1.1.1.3/src/cyberfusion/QueueSupport/__init__.py

@@ -0,0 +1,74 @@
+"""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

python3-cyberfusion-queue-support-1.1.1.1.3/src/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}"

python3-cyberfusion-queue-support-1.1.1.1.3/src/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

python3-cyberfusion-queue-support-1.1.1.1.3/src/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

python3-cyberfusion-queue-support-1.1.1.1.3/src/cyberfusion/QueueSupport/items/chmod.py

@@ -0,0 +1,78 @@
+"""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

python3-cyberfusion-queue-support-1.1.1.1.3/src/cyberfusion/QueueSupport/items/chown.py

@@ -0,0 +1,144 @@
+"""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
+        )

python3-cyberfusion-queue-support-1.1.1.1.3/src/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