python3-cyberfusion-queue-support 1.7.0__py3-none-any.whl → 2.2__py3-none-any.whl

cyberfusion/QueueSupport/items/database_user_ensure_state.py

@@ -0,0 +1,100 @@
+"""Item."""
+
+import logging
+from typing import List, Optional
+
+from cyberfusion.DatabaseSupport.database_users import DatabaseUser
+from cyberfusion.DatabaseSupport.servers import Server
+
+from cyberfusion.QueueSupport.items import _Item
+from cyberfusion.QueueSupport.outcomes import (
+    DatabaseUserEnsureStateItemCreateOutcome,
+    DatabaseUserEnsureStateItemEditPasswordOutcome,
+)
+
+from cyberfusion.DatabaseSupport import DatabaseSupport
+
+logger = logging.getLogger(__name__)
+
+
+class DatabaseUserEnsureStateItem(_Item):
+    """Represents item."""
+
+    def __init__(
+        self,
+        *,
+        server_software_name: str,
+        name: str,
+        password: str,
+        host: Optional[str] = None,
+        reference: Optional[str] = None,
+        hide_outcomes: bool = False,
+    ) -> None:
+        """Set attributes."""
+        self.server_software_name = server_software_name
+        self.name = name
+        self.password = password
+        self._host = host
+        self._reference = reference
+        self._hide_outcomes = hide_outcomes
+
+        self.database_user = DatabaseUser(
+            server=Server(
+                support=DatabaseSupport(
+                    server_software_names=[self.server_software_name]
+                )
+            ),
+            name=self.name,
+            server_software_name=self.server_software_name,
+            password=self.password,
+            host=self._host,
+        )
+
+    @property
+    def outcomes(
+        self,
+    ) -> List[
+        DatabaseUserEnsureStateItemCreateOutcome
+        | DatabaseUserEnsureStateItemEditPasswordOutcome
+    ]:
+        """Get outcomes of item."""
+        outcomes = []
+
+        if not self.database_user.exists:
+            outcomes.append(
+                DatabaseUserEnsureStateItemCreateOutcome(
+                    database_user=self.database_user
+                )
+            )
+        elif self.database_user._get_password() != self.password:
+            outcomes.append(
+                DatabaseUserEnsureStateItemEditPasswordOutcome(
+                    database_user=self.database_user
+                )
+            )
+
+        return outcomes
+
+    def fulfill(self) -> List[DatabaseUserEnsureStateItemCreateOutcome]:
+        """Fulfill outcomes."""
+        outcomes = self.outcomes
+
+        for outcome in outcomes:
+            if isinstance(outcome, DatabaseUserEnsureStateItemCreateOutcome):
+                outcome.database_user.create()
+            else:
+                outcome.database_user.edit()
+
+        return outcomes
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, DatabaseUserEnsureStateItem):
+            return False
+
+        return (
+            other.server_software_name == self.server_software_name
+            and other.name == self.name
+            and other._host == self._host
+            and other.password == self.password
+        )

cyberfusion/QueueSupport/items/database_user_grant_grant.py

@@ -0,0 +1,104 @@
+"""Item."""
+
+import logging
+from typing import List, Optional
+
+from cyberfusion.DatabaseSupport.database_user_grants import DatabaseUserGrant
+from cyberfusion.DatabaseSupport.database_users import DatabaseUser
+from cyberfusion.DatabaseSupport.servers import Server
+from cyberfusion.DatabaseSupport.tables import Table
+
+from cyberfusion.QueueSupport.items import _Item
+from cyberfusion.QueueSupport.outcomes import DatabaseUserGrantGrantItemGrantOutcome
+
+from cyberfusion.DatabaseSupport.databases import Database
+from cyberfusion.DatabaseSupport import DatabaseSupport
+
+logger = logging.getLogger(__name__)
+
+
+class DatabaseUserGrantGrantItem(_Item):
+    """Represents item."""
+
+    def __init__(
+        self,
+        *,
+        server_software_name: str,
+        database_name: str,
+        database_user_name: str,
+        database_user_host: Optional[str] = None,
+        privilege_names: List[str],
+        table: Optional[Table],
+        reference: Optional[str] = None,
+        hide_outcomes: bool = False,
+    ) -> None:
+        """Set attributes."""
+        self.server_software_name = server_software_name
+        self.database_name = database_name
+        self.database_user_name = database_user_name
+        self.database_user_host = database_user_host
+        self.privilege_names = privilege_names
+        self.table = table
+        self._reference = reference
+        self._hide_outcomes = hide_outcomes
+
+        self._database = Database(
+            support=DatabaseSupport(server_software_names=[self.server_software_name]),
+            name=self.database_name,
+            server_software_name=self.server_software_name,
+        )
+
+        self._database_user = DatabaseUser(
+            server=Server(
+                support=DatabaseSupport(
+                    server_software_names=[self.server_software_name]
+                )
+            ),
+            name=self.database_user_name,
+            server_software_name=self.server_software_name,
+            host=self.database_user_host,
+        )
+
+        self.database_user_grant = DatabaseUserGrant(
+            database=self._database,
+            database_user=self._database_user,
+            privilege_names=self.privilege_names,
+            table=self.table,
+        )
+
+    @property
+    def outcomes(self) -> List[DatabaseUserGrantGrantItemGrantOutcome]:
+        """Get outcomes of item."""
+        outcomes = []
+
+        if not self.database_user_grant.exists:
+            outcomes.append(
+                DatabaseUserGrantGrantItemGrantOutcome(
+                    database_user_grant=self.database_user_grant
+                )
+            )
+
+        return outcomes
+
+    def fulfill(self) -> List[DatabaseUserGrantGrantItemGrantOutcome]:
+        """Fulfill outcomes."""
+        outcomes = self.outcomes
+
+        for outcome in outcomes:
+            outcome.database_user_grant.grant()
+
+        return outcomes
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, DatabaseUserGrantGrantItem):
+            return False
+
+        return (
+            other.server_software_name == self.server_software_name
+            and other.database_user_name == self.database_user_name
+            and other.database_user_host == self.database_user_host
+            and other.database_name == self.database_name
+            and other.privilege_names == self.privilege_names
+            and getattr(other.table, "name", None) == getattr(self.table, "name", None)
+        )

cyberfusion/QueueSupport/items/database_user_grant_revoke.py

@@ -0,0 +1,104 @@
+"""Item."""
+
+import logging
+from typing import List, Optional
+
+from cyberfusion.DatabaseSupport.database_user_grants import DatabaseUserGrant
+from cyberfusion.DatabaseSupport.database_users import DatabaseUser
+from cyberfusion.DatabaseSupport.servers import Server
+from cyberfusion.DatabaseSupport.tables import Table
+
+from cyberfusion.QueueSupport.items import _Item
+from cyberfusion.QueueSupport.outcomes import DatabaseUserGrantRevokeItemRevokeOutcome
+
+from cyberfusion.DatabaseSupport.databases import Database
+from cyberfusion.DatabaseSupport import DatabaseSupport
+
+logger = logging.getLogger(__name__)
+
+
+class DatabaseUserGrantRevokeItem(_Item):
+    """Represents item."""
+
+    def __init__(
+        self,
+        *,
+        server_software_name: str,
+        database_name: str,
+        database_user_name: str,
+        database_user_host: Optional[str] = None,
+        privilege_names: List[str],
+        table: Optional[Table],
+        reference: Optional[str] = None,
+        hide_outcomes: bool = False,
+    ) -> None:
+        """Set attributes."""
+        self.server_software_name = server_software_name
+        self.database_name = database_name
+        self.database_user_name = database_user_name
+        self.database_user_host = database_user_host
+        self.privilege_names = privilege_names
+        self.table = table
+        self._reference = reference
+        self._hide_outcomes = hide_outcomes
+
+        self._database = Database(
+            support=DatabaseSupport(server_software_names=[self.server_software_name]),
+            name=self.database_name,
+            server_software_name=self.server_software_name,
+        )
+
+        self._database_user = DatabaseUser(
+            server=Server(
+                support=DatabaseSupport(
+                    server_software_names=[self.server_software_name]
+                )
+            ),
+            name=self.database_user_name,
+            server_software_name=self.server_software_name,
+            host=self.database_user_host,
+        )
+
+        self.database_user_grant = DatabaseUserGrant(
+            database=self._database,
+            database_user=self._database_user,
+            privilege_names=self.privilege_names,
+            table=self.table,
+        )
+
+    @property
+    def outcomes(self) -> List[DatabaseUserGrantRevokeItemRevokeOutcome]:
+        """Get outcomes of item."""
+        outcomes = []
+
+        if self.database_user_grant.exists:
+            outcomes.append(
+                DatabaseUserGrantRevokeItemRevokeOutcome(
+                    database_user_grant=self.database_user_grant
+                )
+            )
+
+        return outcomes
+
+    def fulfill(self) -> List[DatabaseUserGrantRevokeItemRevokeOutcome]:
+        """Fulfill outcomes."""
+        outcomes = self.outcomes
+
+        for outcome in outcomes:
+            outcome.database_user_grant.revoke()
+
+        return outcomes
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, DatabaseUserGrantRevokeItem):
+            return False
+
+        return (
+            other.server_software_name == self.server_software_name
+            and other.database_user_name == self.database_user_name
+            and other.database_user_host == self.database_user_host
+            and other.database_name == self.database_name
+            and other.privilege_names == self.privilege_names
+            and getattr(other.table, "name", None) == getattr(self.table, "name", None)
+        )

cyberfusion/QueueSupport/items/mkdir.py

@@ -43,11 +43,15 @@ class MkdirItem(_Item):
 
         return outcomes
 
-    def fulfill(self) -> None:
+    def fulfill(self) -> List[MkdirItemCreateOutcome]:
         """Fulfill outcomes."""
-        for outcome in self.outcomes:
+        outcomes = self.outcomes
+
+        for outcome in outcomes:
             os.mkdir(outcome.path)
 
+        return outcomes
+
     def __eq__(self, other: object) -> bool:
         """Get equality based on attributes."""
         if not isinstance(other, MkdirItem):

cyberfusion/QueueSupport/items/move.py

@@ -46,11 +46,15 @@ class MoveItem(_Item):
 
         return outcomes
 
-    def fulfill(self) -> None:
+    def fulfill(self) -> List[MoveItemMoveOutcome]:
         """Fulfill outcomes."""
-        for outcome in self.outcomes:
+        outcomes = self.outcomes
+
+        for outcome in outcomes:
             shutil.move(outcome.source, outcome.destination)
 
+        return outcomes
+
     def __eq__(self, other: object) -> bool:
         """Get equality based on attributes."""
         if not isinstance(other, MoveItem):

cyberfusion/QueueSupport/items/rmtree.py

@@ -44,11 +44,15 @@ class RmTreeItem(_Item):
 
         return outcomes
 
-    def fulfill(self) -> None:
+    def fulfill(self) -> List[RmTreeItemRemoveOutcome]:
         """Fulfill outcomes."""
-        for outcome in self.outcomes:
+        outcomes = self.outcomes
+
+        for outcome in outcomes:
             shutil.rmtree(outcome.path)
 
+        return outcomes
+
     def __eq__(self, other: object) -> bool:
         """Get equality based on attributes."""
         if not isinstance(other, RmTreeItem):

cyberfusion/QueueSupport/items/systemd_daemon_reload.py

@@ -35,11 +35,15 @@ class SystemdDaemonReloadItem(_Item):
 
         return outcomes
 
-    def fulfill(self) -> None:
+    def fulfill(self) -> List[SystemdDaemonReloadItemReloadOutcome]:
         """Fulfill outcomes."""
-        for _ in self.outcomes:
+        outcomes = self.outcomes
+
+        for _ in outcomes:
             SystemdManager.daemon_reload()
 
+        return outcomes
+
     def __eq__(self, other: object) -> bool:
         """Get equality based on attributes."""
         if not isinstance(other, SystemdDaemonReloadItem):

cyberfusion/QueueSupport/items/systemd_tmp_files_create.py

@@ -36,11 +36,15 @@ class SystemdTmpFilesCreateItem(_Item):
 
         return outcomes
 
-    def fulfill(self) -> None:
+    def fulfill(self) -> List[SystemdTmpFilesCreateItemCreateOutcome]:
         """Fulfill outcomes."""
-        for outcome in self.outcomes:
+        outcomes = self.outcomes
+
+        for outcome in outcomes:
             TmpFileConfigurationFile(outcome.path).create()
 
+        return outcomes
+
     def __eq__(self, other: object) -> bool:
         """Get equality based on attributes."""
         if not isinstance(other, SystemdTmpFilesCreateItem):

cyberfusion/QueueSupport/items/systemd_unit_disable.py

@@ -39,11 +39,15 @@ class SystemdUnitDisableItem(_Item):
 
         return outcomes
 
-    def fulfill(self) -> None:
+    def fulfill(self) -> List[SystemdUnitDisableItemDisableOutcome]:
         """Fulfill outcomes."""
-        for outcome in self.outcomes:
+        outcomes = self.outcomes
+
+        for outcome in outcomes:
             outcome.unit.disable()
 
+        return outcomes
+
     def __eq__(self, other: object) -> bool:
         """Get equality based on attributes."""
         if not isinstance(other, SystemdUnitDisableItem):

cyberfusion/QueueSupport/items/systemd_unit_enable.py

@@ -39,11 +39,15 @@ class SystemdUnitEnableItem(_Item):
 
         return outcomes
 
-    def fulfill(self) -> None:
+    def fulfill(self) -> List[SystemdUnitEnableItemEnableOutcome]:
         """Fulfill outcomes."""
-        for outcome in self.outcomes:
+        outcomes = self.outcomes
+
+        for outcome in outcomes:
             outcome.unit.enable()
 
+        return outcomes
+
     def __eq__(self, other: object) -> bool:
         """Get equality based on attributes."""
         if not isinstance(other, SystemdUnitEnableItem):

cyberfusion/QueueSupport/items/systemd_unit_reload.py

@@ -38,11 +38,15 @@ class SystemdUnitReloadItem(_Item):
 
         return outcomes
 
-    def fulfill(self) -> None:
+    def fulfill(self) -> List[SystemdUnitReloadItemReloadOutcome]:
         """Fulfill outcomes."""
-        for outcome in self.outcomes:
+        outcomes = self.outcomes
+
+        for outcome in outcomes:
             outcome.unit.reload()
 
+        return outcomes
+
     def __eq__(self, other: object) -> bool:
         """Get equality based on attributes."""
         if not isinstance(other, SystemdUnitReloadItem):

cyberfusion/QueueSupport/items/systemd_unit_restart.py

@@ -38,11 +38,15 @@ class SystemdUnitRestartItem(_Item):
 
         return outcomes
 
-    def fulfill(self) -> None:
+    def fulfill(self) -> List[SystemdUnitRestartItemRestartOutcome]:
         """Fulfill outcomes."""
-        for outcome in self.outcomes:
+        outcomes = self.outcomes
+
+        for outcome in outcomes:
             outcome.unit.restart()
 
+        return outcomes
+
     def __eq__(self, other: object) -> bool:
         """Get equality based on attributes."""
         if not isinstance(other, SystemdUnitRestartItem):

cyberfusion/QueueSupport/items/systemd_unit_start.py

@@ -39,11 +39,15 @@ class SystemdUnitStartItem(_Item):
 
         return outcomes
 
-    def fulfill(self) -> None:
+    def fulfill(self) -> List[SystemdUnitStartItemStartOutcome]:
         """Fulfill outcomes."""
-        for outcome in self.outcomes:
+        outcomes = self.outcomes
+
+        for outcome in outcomes:
             outcome.unit.start()
 
+        return outcomes
+
     def __eq__(self, other: object) -> bool:
         """Get equality based on attributes."""
         if not isinstance(other, SystemdUnitStartItem):

cyberfusion/QueueSupport/items/systemd_unit_stop.py

@@ -37,11 +37,15 @@ class SystemdUnitStopItem(_Item):
 
         return outcomes
 
-    def fulfill(self) -> None:
+    def fulfill(self) -> List[SystemdUnitStopItemStopOutcome]:
         """Fulfill outcomes."""
-        for outcome in self.outcomes:
+        outcomes = self.outcomes
+
+        for outcome in outcomes:
             outcome.unit.stop()
 
+        return outcomes
+
     def __eq__(self, other: object) -> bool:
         """Get equality based on attributes."""
         if not isinstance(other, SystemdUnitStopItem):

cyberfusion/QueueSupport/items/unlink.py

@@ -43,11 +43,15 @@ class UnlinkItem(_Item):
 
         return outcomes
 
-    def fulfill(self) -> None:
+    def fulfill(self) -> List[UnlinkItemUnlinkOutcome]:
         """Fulfill outcomes."""
-        for outcome in self.outcomes:
+        outcomes = self.outcomes
+
+        for outcome in outcomes:
             os.unlink(outcome.path)
 
+        return outcomes
+
     def __eq__(self, other: object) -> bool:
         """Get equality based on attributes."""
         if not isinstance(other, UnlinkItem):