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

cyberfusion/QueueSupport/items/systemd_unit_disable.py

@@ -0,0 +1,59 @@
+"""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 (
+    SystemdUnitDisableItemDisableOutcome,
+)
+from cyberfusion.SystemdSupport.units import Unit
+
+logger = logging.getLogger(__name__)
+
+
+class SystemdUnitDisableItem(_Item):
+    """Represents item."""
+
+    def __init__(
+        self,
+        *,
+        name: str,
+        reference: Optional[str] = None,
+        hide_outcomes: bool = False,
+    ) -> None:
+        """Set attributes."""
+        self.name = name
+        self._reference = reference
+        self._hide_outcomes = hide_outcomes
+
+        self.unit = Unit(self.name)
+
+    @property
+    def outcomes(self) -> List[OutcomeInterface]:
+        """Get outcomes of calling self.fulfill."""
+        outcomes = []
+
+        if self.unit.is_enabled:
+            outcomes.append(SystemdUnitDisableItemDisableOutcome(unit=self.unit))
+
+        return outcomes
+
+    def fulfill(self) -> None:
+        """Fulfill outcomes."""
+        systemd_unit_disable_outcomes = [
+            x
+            for x in self.outcomes
+            if isinstance(x, SystemdUnitDisableItemDisableOutcome)
+        ]
+
+        if systemd_unit_disable_outcomes:
+            systemd_unit_disable_outcomes[0].unit.disable()
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, SystemdUnitDisableItem):
+            return False
+
+        return other.name == self.name

cyberfusion/QueueSupport/items/systemd_unit_enable.py

@@ -0,0 +1,59 @@
+"""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 (
+    SystemdUnitEnableItemEnableOutcome,
+)
+from cyberfusion.SystemdSupport.units import Unit
+
+logger = logging.getLogger(__name__)
+
+
+class SystemdUnitEnableItem(_Item):
+    """Represents item."""
+
+    def __init__(
+        self,
+        *,
+        name: str,
+        reference: Optional[str] = None,
+        hide_outcomes: bool = False,
+    ) -> None:
+        """Set attributes."""
+        self.name = name
+        self._reference = reference
+        self._hide_outcomes = hide_outcomes
+
+        self.unit = Unit(self.name)
+
+    @property
+    def outcomes(self) -> List[OutcomeInterface]:
+        """Get outcomes of calling self.fulfill."""
+        outcomes = []
+
+        if not self.unit.is_enabled:
+            outcomes.append(SystemdUnitEnableItemEnableOutcome(unit=self.unit))
+
+        return outcomes
+
+    def fulfill(self) -> None:
+        """Fulfill outcomes."""
+        systemd_unit_enable_outcomes = [
+            x
+            for x in self.outcomes
+            if isinstance(x, SystemdUnitEnableItemEnableOutcome)
+        ]
+
+        if systemd_unit_enable_outcomes:
+            systemd_unit_enable_outcomes[0].unit.enable()
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, SystemdUnitEnableItem):
+            return False
+
+        return other.name == self.name

cyberfusion/QueueSupport/items/systemd_unit_reload.py

@@ -0,0 +1,57 @@
+"""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 (
+    SystemdUnitReloadItemReloadOutcome,
+)
+from cyberfusion.SystemdSupport.units import Unit
+
+logger = logging.getLogger(__name__)
+
+
+class SystemdUnitReloadItem(_Item):
+    """Represents item."""
+
+    def __init__(
+        self,
+        *,
+        name: str,
+        reference: Optional[str] = None,
+        hide_outcomes: bool = False,
+    ) -> None:
+        """Set attributes."""
+        self.name = name
+        self._reference = reference
+        self._hide_outcomes = hide_outcomes
+
+        self.unit = Unit(self.name)
+
+    @property
+    def outcomes(self) -> List[OutcomeInterface]:
+        """Get outcomes of calling self.fulfill."""
+        outcomes = []
+
+        outcomes.append(SystemdUnitReloadItemReloadOutcome(unit=self.unit))
+
+        return outcomes
+
+    def fulfill(self) -> None:
+        """Fulfill outcomes."""
+        systemd_unit_reload_outcomes = [
+            x
+            for x in self.outcomes
+            if isinstance(x, SystemdUnitReloadItemReloadOutcome)
+        ]
+
+        systemd_unit_reload_outcomes[0].unit.reload()
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, SystemdUnitReloadItem):
+            return False
+
+        return other.name == self.name

cyberfusion/QueueSupport/items/systemd_unit_restart.py

@@ -0,0 +1,57 @@
+"""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 (
+    SystemdUnitRestartItemRestartOutcome,
+)
+from cyberfusion.SystemdSupport.units import Unit
+
+logger = logging.getLogger(__name__)
+
+
+class SystemdUnitRestartItem(_Item):
+    """Represents item."""
+
+    def __init__(
+        self,
+        *,
+        name: str,
+        reference: Optional[str] = None,
+        hide_outcomes: bool = False,
+    ) -> None:
+        """Set attributes."""
+        self.name = name
+        self._reference = reference
+        self._hide_outcomes = hide_outcomes
+
+        self.unit = Unit(self.name)
+
+    @property
+    def outcomes(self) -> List[OutcomeInterface]:
+        """Get outcomes of calling self.fulfill."""
+        outcomes = []
+
+        outcomes.append(SystemdUnitRestartItemRestartOutcome(unit=self.unit))
+
+        return outcomes
+
+    def fulfill(self) -> None:
+        """Fulfill outcomes."""
+        systemd_unit_restart_outcomes = [
+            x
+            for x in self.outcomes
+            if isinstance(x, SystemdUnitRestartItemRestartOutcome)
+        ]
+
+        systemd_unit_restart_outcomes[0].unit.restart()
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, SystemdUnitRestartItem):
+            return False
+
+        return other.name == self.name

cyberfusion/QueueSupport/items/systemd_unit_stop.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 SystemdUnitStopItemStopOutcome
+from cyberfusion.SystemdSupport.units import Unit
+
+logger = logging.getLogger(__name__)
+
+
+class SystemdUnitStopItem(_Item):
+    """Represents item."""
+
+    def __init__(
+        self,
+        *,
+        name: str,
+        reference: Optional[str] = None,
+        hide_outcomes: bool = False,
+    ) -> None:
+        """Set attributes."""
+        self.name = name
+        self._reference = reference
+        self._hide_outcomes = hide_outcomes
+
+        self.unit = Unit(self.name)
+
+    @property
+    def outcomes(self) -> List[OutcomeInterface]:
+        """Get outcomes of calling self.fulfill."""
+        outcomes = []
+
+        if self.unit.is_active:
+            outcomes.append(SystemdUnitStopItemStopOutcome(unit=self.unit))
+
+        return outcomes
+
+    def fulfill(self) -> None:
+        """Fulfill outcomes."""
+        systemd_unit_stop_outcomes = [
+            x for x in self.outcomes if isinstance(x, SystemdUnitStopItemStopOutcome)
+        ]
+
+        if systemd_unit_stop_outcomes:
+            systemd_unit_stop_outcomes[0].unit.stop()
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, SystemdUnitStopItem):
+            return False
+
+        return other.name == self.name

cyberfusion/QueueSupport/items/unlink.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 UnlinkItemUnlinkOutcome
+
+logger = logging.getLogger(__name__)
+
+
+class UnlinkItem(_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 os.path.exists(self.path):
+            outcomes.append(
+                UnlinkItemUnlinkOutcome(
+                    path=self.path,
+                )
+            )
+
+        return outcomes
+
+    def fulfill(self) -> None:
+        """Fulfill outcomes."""
+        unlink_outcomes = [
+            x for x in self.outcomes if isinstance(x, UnlinkItemUnlinkOutcome)
+        ]
+
+        if unlink_outcomes:
+            os.unlink(unlink_outcomes[0].path)
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, UnlinkItem):
+            return False
+
+        return other.path == self.path

cyberfusion/QueueSupport/outcomes.py

@@ -0,0 +1,305 @@
+"""Outcomes."""
+
+from typing import List, Optional
+
+from cyberfusion.QueueSupport.interfaces import OutcomeInterface
+from cyberfusion.SystemdSupport.units import Unit
+
+
+class CopyItemCopyOutcome(OutcomeInterface):
+    """Represents outcome."""
+
+    def __init__(self, *, source: str, destination: str) -> None:
+        """Set attributes."""
+        self.source = source
+        self.destination = destination
+
+    def __str__(self) -> str:
+        """Get human-readable string."""
+        return f"Copy {self.source} to {self.destination}"
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, CopyItemCopyOutcome):
+            return False
+
+        return other.source == self.source and other.destination == self.destination
+
+
+class MoveItemMoveOutcome(OutcomeInterface):
+    """Represents outcome."""
+
+    def __init__(self, *, source: str, destination: str) -> None:
+        """Set attributes."""
+        self.source = source
+        self.destination = destination
+
+    def __str__(self) -> str:
+        """Get human-readable string."""
+        return f"Move {self.source} to {self.destination}"
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, MoveItemMoveOutcome):
+            return False
+
+        return other.source == self.source and other.destination == self.destination
+
+
+class MkdirItemCreateOutcome(OutcomeInterface):
+    """Represents outcome."""
+
+    def __init__(self, *, path: str) -> None:
+        """Set attributes."""
+        self.path = path
+
+    def __str__(self) -> str:
+        """Get human-readable string."""
+        return f"Create {self.path}"
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, MkdirItemCreateOutcome):
+            return False
+
+        return other.path == self.path
+
+
+class SystemdTmpFilesCreateItemCreateOutcome(OutcomeInterface):
+    """Represents outcome."""
+
+    def __init__(self, *, path: str) -> None:
+        """Set attributes."""
+        self.path = path
+
+    def __str__(self) -> str:
+        """Get human-readable string."""
+        return (
+            f"Create tmp files according to tmp files configuration file at {self.path}"
+        )
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, SystemdTmpFilesCreateItemCreateOutcome):
+            return False
+
+        return other.path == self.path
+
+
+class UnlinkItemUnlinkOutcome(OutcomeInterface):
+    """Represents outcome."""
+
+    def __init__(self, *, path: str) -> None:
+        """Set attributes."""
+        self.path = path
+
+    def __str__(self) -> str:
+        """Get human-readable string."""
+        return f"Unlink {self.path}"
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, UnlinkItemUnlinkOutcome):
+            return False
+
+        return other.path == self.path
+
+
+class CommandItemRunOutcome(OutcomeInterface):
+    """Represents outcome."""
+
+    def __init__(self, *, command: List[str]) -> None:
+        """Set attributes."""
+        self.command = command
+
+    def __str__(self) -> str:
+        """Get human-readable string."""
+        return f"Run {self.command}"
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, CommandItemRunOutcome):
+            return False
+
+        return other.command == self.command
+
+
+class ChmodItemModeChangeOutcome(OutcomeInterface):
+    """Represents outcome."""
+
+    def __init__(self, *, path: str, old_mode: Optional[int], new_mode: int) -> None:
+        """Set attributes."""
+        self.path = path
+        self.old_mode = old_mode
+        self.new_mode = new_mode
+
+    def __str__(self) -> str:
+        """Get human-readable string."""
+        old_mode: Optional[str]
+
+        if self.old_mode is not None:
+            old_mode = oct(self.old_mode)
+        else:
+            old_mode = None
+
+        return f"Change mode of {self.path} from {old_mode} to {oct(self.new_mode)}"
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, ChmodItemModeChangeOutcome):
+            return False
+
+        return (
+            other.path == self.path
+            and other.old_mode == self.old_mode
+            and other.new_mode == self.new_mode
+        )
+
+
+class ChownItemOwnerChangeOutcome(OutcomeInterface):
+    """Represents outcome."""
+
+    def __init__(
+        self, *, path: str, old_owner_name: Optional[str], new_owner_name: str
+    ) -> None:
+        """Set attributes."""
+        self.path = path
+        self.old_owner_name = old_owner_name
+        self.new_owner_name = new_owner_name
+
+    def __str__(self) -> str:
+        """Get human-readable string."""
+        return f"Change owner of {self.path} from {self.old_owner_name} to {self.new_owner_name}"
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, ChownItemOwnerChangeOutcome):
+            return False
+
+        return (
+            other.path == self.path
+            and other.old_owner_name == self.old_owner_name
+            and other.new_owner_name == self.new_owner_name
+        )
+
+
+class ChownItemGroupChangeOutcome(OutcomeInterface):
+    """Represents outcome."""
+
+    def __init__(
+        self, *, path: str, old_group_name: Optional[str], new_group_name: str
+    ) -> None:
+        """Set attributes."""
+        self.path = path
+        self.old_group_name = old_group_name
+        self.new_group_name = new_group_name
+
+    def __str__(self) -> str:
+        """Get human-readable string."""
+        return f"Change group of {self.path} from {self.old_group_name} to {self.new_group_name}"
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, ChownItemGroupChangeOutcome):
+            return False
+
+        return (
+            other.path == self.path
+            and other.old_group_name == self.old_group_name
+            and other.new_group_name == self.new_group_name
+        )
+
+
+class SystemdUnitEnableItemEnableOutcome(OutcomeInterface):
+    """Represents outcome."""
+
+    def __init__(self, *, unit: Unit) -> None:
+        """Set attributes."""
+        self.unit = unit
+
+    def __str__(self) -> str:
+        """Get human-readable string."""
+        return f"Enable {self.unit.name}"
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, SystemdUnitEnableItemEnableOutcome):
+            return False
+
+        return other.unit.name == self.unit.name
+
+
+class SystemdUnitDisableItemDisableOutcome(OutcomeInterface):
+    """Represents outcome."""
+
+    def __init__(self, *, unit: Unit) -> None:
+        """Set attributes."""
+        self.unit = unit
+
+    def __str__(self) -> str:
+        """Get human-readable string."""
+        return f"Disable {self.unit.name}"
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, SystemdUnitDisableItemDisableOutcome):
+            return False
+
+        return other.unit.name == self.unit.name
+
+
+class SystemdUnitRestartItemRestartOutcome(OutcomeInterface):
+    """Represents outcome."""
+
+    def __init__(self, *, unit: Unit) -> None:
+        """Set attributes."""
+        self.unit = unit
+
+    def __str__(self) -> str:
+        """Get human-readable string."""
+        return f"Restart {self.unit.name}"
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, SystemdUnitRestartItemRestartOutcome):
+            return False
+
+        return other.unit.name == self.unit.name
+
+
+class SystemdUnitReloadItemReloadOutcome(OutcomeInterface):
+    """Represents outcome."""
+
+    def __init__(self, *, unit: Unit) -> None:
+        """Set attributes."""
+        self.unit = unit
+
+    def __str__(self) -> str:
+        """Get human-readable string."""
+        return f"Reload {self.unit.name}"
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, SystemdUnitReloadItemReloadOutcome):
+            return False
+
+        return other.unit.name == self.unit.name
+
+
+class SystemdUnitStopItemStopOutcome(OutcomeInterface):
+    """Represents outcome."""
+
+    def __init__(self, *, unit: Unit) -> None:
+        """Set attributes."""
+        self.unit = unit
+
+    def __str__(self) -> str:
+        """Get human-readable string."""
+        return f"Stop {self.unit.name}"
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, SystemdUnitStopItemStopOutcome):
+            return False
+
+        return other.unit.name == self.unit.name

cyberfusion/QueueSupport/utilities.py

@@ -0,0 +1,9 @@
+"""Utilities."""
+
+import os
+import stat
+
+
+def get_decimal_permissions(path: str) -> int:
+    """Get decimal permissions with all bits."""
+    return stat.S_IMODE(os.lstat(path).st_mode)