python3-cyberfusion-queue-support 2.0__tar.gz → 2.2.1__tar.gz

{python3_cyberfusion_queue_support-2.0 → python3_cyberfusion_queue_support-2.2.1}/PKG-INFO

@@ -1,13 +1,15 @@
 Metadata-Version: 2.4
 Name: python3-cyberfusion-queue-support
-Version: 2.0
+Version: 2.2.1
 Summary: Library to queue actions.
 Author-email: Cyberfusion <support@cyberfusion.io>
 Project-URL: Source, https://github.com/CyberfusionIO/python3-cyberfusion-queue-support
 Description-Content-Type: text/markdown
 Requires-Dist: python3-cyberfusion-systemd-support~=2.1
+Requires-Dist: python3-cyberfusion-database-support~=3.0
 Requires-Dist: alembic==1.8.1
 Requires-Dist: SQLAlchemy==1.4.46
+Requires-Dist: pydantic[dotenv]==1.10.4
 
 # python3-cyberfusion-queue-support
 
@@ -48,6 +50,10 @@ Run the following command to install the package from PyPI:
 
     pip3 install python3-cyberfusion-queue-support
 
+Then, run database migrations:
+
+    bin/queue-support-migrate
+
 ## Debian
 
 Run the following commands to build a Debian package:

{python3_cyberfusion_queue_support-2.0 → python3_cyberfusion_queue_support-2.2.1}/README.md

@@ -37,6 +37,10 @@ Run the following command to install the package from PyPI:
 
     pip3 install python3-cyberfusion-queue-support
 
+Then, run database migrations:
+
+    bin/queue-support-migrate
+
 ## Debian
 
 Run the following commands to build a Debian package:

{python3_cyberfusion_queue_support-2.0 → python3_cyberfusion_queue_support-2.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python3-cyberfusion-queue-support"
-version = "2.0"
+version = "2.2.1"
 description = "Library to queue actions."
 readme = "README.md"
 authors = [
@@ -12,9 +12,19 @@ authors = [
 ]
 dependencies = [
     "python3-cyberfusion-systemd-support~=2.1",
+    "python3-cyberfusion-database-support~=3.0",
     "alembic==1.8.1",
     "SQLAlchemy==1.4.46",
+    "pydantic[dotenv]==1.10.4",
 ]
 
 [project.urls]
 "Source" = "https://github.com/CyberfusionIO/python3-cyberfusion-queue-support"
+
+[project.scripts]
+queue-support-migrate = "cyberfusion.QueueSupport.database:run_migrations"
+
+[tool.coverage.run]
+omit = [
+    "*/migrations/*"
+]

{python3_cyberfusion_queue_support-2.0 → python3_cyberfusion_queue_support-2.2.1}/src/cyberfusion/QueueSupport/database.py

@@ -1,4 +1,6 @@
+from alembic.config import Config
 import os
+from alembic import command
 import sqlite3
 from datetime import datetime, timezone
 from sqlalchemy.pool.base import _ConnectionRecord
@@ -10,6 +12,8 @@ from sqlalchemy.engine import Engine
 from sqlalchemy import event
 from sqlalchemy.types import JSON
 
+from cyberfusion.QueueSupport.settings import settings
+
 
 @event.listens_for(Engine, "connect")  # type: ignore[misc]
 def set_sqlite_pragma(
@@ -28,14 +32,22 @@ def set_sqlite_pragma(
     cursor.close()
 
 
-def get_database_path() -> str: # pragma: no cover
-    """Get database path."""
-    return os.path.join(os.path.sep, "var", "lib", "queue-support.db")
+def run_migrations() -> None:
+    """Upgrade database schema to latest version."""
+    alembic_config = Config()
+
+    alembic_config.set_main_option("sqlalchemy.url", settings.database_path)
+    alembic_config.set_main_option(
+        "script_location",
+        os.path.join(os.path.dirname(os.path.realpath(__file__)), "migrations"),
+    )
+
+    command.upgrade(alembic_config, "head")
 
 
 def make_database_session() -> Session:
     engine = create_engine(
-        "sqlite:///" + get_database_path(), connect_args={"check_same_thread": False}
+        settings.database_path, connect_args={"check_same_thread": False}
     )
 
     return sessionmaker(bind=engine)()

{python3_cyberfusion_queue_support-2.0 → python3_cyberfusion_queue_support-2.2.1}/src/cyberfusion/QueueSupport/items/__init__.py

@@ -18,7 +18,7 @@ class _Item(ItemInterface, ABC):
         *,
         reference: Optional[str] = None,
         hide_outcomes: bool = False,
-    ) -> None: # pragma: no cover
+    ) -> None:  # pragma: no cover
         """Set attributes."""
         self._reference = reference
         self._hide_outcomes = hide_outcomes

python3_cyberfusion_queue_support-2.2.1/src/cyberfusion/QueueSupport/items/database_create.py

@@ -0,0 +1,65 @@
+"""Item."""
+
+import logging
+from typing import List, Optional
+
+from cyberfusion.QueueSupport.items import _Item
+from cyberfusion.QueueSupport.outcomes import DatabaseCreateItemCreateOutcome
+
+from cyberfusion.DatabaseSupport.databases import Database
+from cyberfusion.DatabaseSupport import DatabaseSupport
+
+logger = logging.getLogger(__name__)
+
+
+class DatabaseCreateItem(_Item):
+    """Represents item."""
+
+    def __init__(
+        self,
+        *,
+        server_software_name: str,
+        name: str,
+        reference: Optional[str] = None,
+        hide_outcomes: bool = False,
+    ) -> None:
+        """Set attributes."""
+        self.server_software_name = server_software_name
+        self.name = name
+        self._reference = reference
+        self._hide_outcomes = hide_outcomes
+
+        self.database = Database(
+            support=DatabaseSupport(server_software_names=[self.server_software_name]),
+            name=self.name,
+            server_software_name=self.server_software_name,
+        )
+
+    @property
+    def outcomes(self) -> List[DatabaseCreateItemCreateOutcome]:
+        """Get outcomes of item."""
+        outcomes = []
+
+        if not self.database.exists:
+            outcomes.append(DatabaseCreateItemCreateOutcome(database=self.database))
+
+        return outcomes
+
+    def fulfill(self) -> List[DatabaseCreateItemCreateOutcome]:
+        """Fulfill outcomes."""
+        outcomes = self.outcomes
+
+        for outcome in outcomes:
+            outcome.database.create()
+
+        return outcomes
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, DatabaseCreateItem):
+            return False
+
+        return (
+            other.server_software_name == self.server_software_name
+            and other.name == self.name
+        )

python3_cyberfusion_queue_support-2.2.1/src/cyberfusion/QueueSupport/items/database_drop.py

@@ -0,0 +1,65 @@
+"""Item."""
+
+import logging
+from typing import List, Optional
+
+from cyberfusion.QueueSupport.items import _Item
+from cyberfusion.QueueSupport.outcomes import DatabaseDropItemDropOutcome
+
+from cyberfusion.DatabaseSupport.databases import Database
+from cyberfusion.DatabaseSupport import DatabaseSupport
+
+logger = logging.getLogger(__name__)
+
+
+class DatabaseDropItem(_Item):
+    """Represents item."""
+
+    def __init__(
+        self,
+        *,
+        server_software_name: str,
+        name: str,
+        reference: Optional[str] = None,
+        hide_outcomes: bool = False,
+    ) -> None:
+        """Set attributes."""
+        self.server_software_name = server_software_name
+        self.name = name
+        self._reference = reference
+        self._hide_outcomes = hide_outcomes
+
+        self.database = Database(
+            support=DatabaseSupport(server_software_names=[self.server_software_name]),
+            name=self.name,
+            server_software_name=self.server_software_name,
+        )
+
+    @property
+    def outcomes(self) -> List[DatabaseDropItemDropOutcome]:
+        """Get outcomes of item."""
+        outcomes = []
+
+        if self.database.exists:
+            outcomes.append(DatabaseDropItemDropOutcome(database=self.database))
+
+        return outcomes
+
+    def fulfill(self) -> List[DatabaseDropItemDropOutcome]:
+        """Fulfill outcomes."""
+        outcomes = self.outcomes
+
+        for outcome in outcomes:
+            outcome.database.drop()
+
+        return outcomes
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, DatabaseDropItem):
+            return False
+
+        return (
+            other.server_software_name == self.server_software_name
+            and other.name == self.name
+        )

python3_cyberfusion_queue_support-2.2.1/src/cyberfusion/QueueSupport/items/database_user_drop.py

@@ -0,0 +1,81 @@
+"""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 (
+    DatabaseUserDropItemDropOutcome,
+)
+
+from cyberfusion.DatabaseSupport import DatabaseSupport
+
+logger = logging.getLogger(__name__)
+
+
+class DatabaseUserDropItem(_Item):
+    """Represents item."""
+
+    def __init__(
+        self,
+        *,
+        server_software_name: str,
+        name: 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._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,
+            host=self._host,
+        )
+
+    @property
+    def outcomes(
+        self,
+    ) -> List[DatabaseUserDropItemDropOutcome]:
+        """Get outcomes of item."""
+        outcomes = []
+
+        if self.database_user.exists:
+            outcomes.append(
+                DatabaseUserDropItemDropOutcome(database_user=self.database_user)
+            )
+
+        return outcomes
+
+    def fulfill(self) -> List[DatabaseUserDropItemDropOutcome]:
+        """Fulfill outcomes."""
+        outcomes = self.outcomes
+
+        for outcome in outcomes:
+            outcome.database_user.drop()
+
+        return outcomes
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, DatabaseUserDropItem):
+            return False
+
+        return (
+            other.server_software_name == self.server_software_name
+            and other.name == self.name
+            and other._host == self._host
+        )

python3_cyberfusion_queue_support-2.2.1/src/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
+        )

python3_cyberfusion_queue_support-2.2.1/src/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)
+        )

python3_cyberfusion_queue_support-2.2.1/src/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)
+        )

python3_cyberfusion_queue_support-2.2.1/src/cyberfusion/QueueSupport/migrations/env.py

@@ -0,0 +1,49 @@
+from logging.config import fileConfig
+
+from sqlalchemy import engine_from_config
+from sqlalchemy import pool
+
+from alembic import context
+
+from cyberfusion.QueueSupport import database
+
+config = context.config
+
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+target_metadata = database.metadata
+
+
+def run_migrations_offline() -> None:
+    url = config.get_main_option("sqlalchemy.url")
+
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(connection=connection, target_metadata=target_metadata)
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

python3_cyberfusion_queue_support-2.2.1/src/cyberfusion/QueueSupport/migrations/versions/571e55ab5ed5_initial_migration.py

@@ -0,0 +1,82 @@
+"""Initial migration
+
+Revision ID: 571e55ab5ed5
+Revises:
+Create Date: 2025-04-09 18:46:38.122919
+
+"""
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = "571e55ab5ed5"
+down_revision = None
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.create_table(
+        "queues",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("created_at", sa.DateTime(), nullable=False),
+        sa.PrimaryKeyConstraint("id", name=op.f("pk_queues")),
+    )
+
+    op.create_table(
+        "queue_items",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("created_at", sa.DateTime(), nullable=False),
+        sa.Column("queue_id", sa.Integer(), nullable=False),
+        sa.Column("type", sa.String(length=255), nullable=False),
+        sa.Column("reference", sa.String(length=255), nullable=True),
+        sa.Column("hide_outcomes", sa.Boolean(), nullable=False),
+        sa.Column("deduplicated", sa.Boolean(), nullable=False),
+        sa.Column("attributes", sa.JSON(), nullable=False),
+        sa.ForeignKeyConstraint(
+            ["queue_id"], ["queues.id"], name=op.f("fk_queue_items_queue_id_queues")
+        ),
+        sa.PrimaryKeyConstraint("id", name=op.f("pk_queue_items")),
+    )
+
+    op.create_table(
+        "queue_processes",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("created_at", sa.DateTime(), nullable=False),
+        sa.Column("queue_id", sa.Integer(), nullable=False),
+        sa.Column("preview", sa.Boolean(), nullable=False),
+        sa.ForeignKeyConstraint(
+            ["queue_id"], ["queues.id"], name=op.f("fk_queue_processes_queue_id_queues")
+        ),
+        sa.PrimaryKeyConstraint("id", name=op.f("pk_queue_processes")),
+    )
+
+    op.create_table(
+        "queue_item_outcomes",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("created_at", sa.DateTime(), nullable=False),
+        sa.Column("queue_item_id", sa.Integer(), nullable=False),
+        sa.Column("queue_process_id", sa.Integer(), nullable=False),
+        sa.Column("type", sa.String(length=255), nullable=False),
+        sa.Column("attributes", sa.JSON(), nullable=False),
+        sa.ForeignKeyConstraint(
+            ["queue_item_id"],
+            ["queue_items.id"],
+            name=op.f("fk_queue_item_outcomes_queue_item_id_queue_items"),
+        ),
+        sa.ForeignKeyConstraint(
+            ["queue_process_id"],
+            ["queue_processes.id"],
+            name=op.f("fk_queue_item_outcomes_queue_process_id_queue_processes"),
+        ),
+        sa.PrimaryKeyConstraint("id", name=op.f("pk_queue_item_outcomes")),
+    )
+
+
+def downgrade() -> None:
+    op.drop_table("queue_item_outcomes")
+    op.drop_table("queue_processes")
+    op.drop_table("queue_items")
+    op.drop_table("queues")

{python3_cyberfusion_queue_support-2.0 → python3_cyberfusion_queue_support-2.2.1}/src/cyberfusion/QueueSupport/outcomes.py

@@ -2,6 +2,10 @@
 
 from typing import List, Optional
 
+from cyberfusion.DatabaseSupport.database_user_grants import DatabaseUserGrant
+from cyberfusion.DatabaseSupport.database_users import DatabaseUser
+from cyberfusion.DatabaseSupport.databases import Database
+
 from cyberfusion.QueueSupport.interfaces import OutcomeInterface
 from cyberfusion.SystemdSupport.units import Unit
 
@@ -10,7 +14,11 @@ class CopyItemCopyOutcome(OutcomeInterface):
     """Represents outcome."""
 
     def __init__(
-        self, *, source: str, destination: str, changed_lines: Optional[list[str]] = None
+        self,
+        *,
+        source: str,
+        destination: str,
+        changed_lines: Optional[list[str]] = None,
     ) -> None:
         """Set attributes."""
         self.source = source
@@ -24,9 +32,7 @@ class CopyItemCopyOutcome(OutcomeInterface):
         else:
             changed_lines = ""
 
-        return (
-            f"Copy {self.source} to {self.destination}.{changed_lines}"
-        )
+        return f"Copy {self.source} to {self.destination}.{changed_lines}"
 
     def __eq__(self, other: object) -> bool:
         """Get equality based on attributes."""
@@ -376,3 +382,194 @@ class SystemdUnitStopItemStopOutcome(OutcomeInterface):
             return False
 
         return other.unit.name == self.unit.name
+
+
+class DatabaseCreateItemCreateOutcome(OutcomeInterface):
+    """Represents outcome."""
+
+    def __init__(self, *, database: Database) -> None:
+        """Set attributes."""
+        self.database = database
+
+    def __str__(self) -> str:
+        """Get human-readable string."""
+        return f"Create {self.database.name} in {self.database.server_software_name}"
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, DatabaseCreateItemCreateOutcome):
+            return False
+
+        return (
+            other.database.server_software_name == self.database.server_software_name
+            and other.database.name == self.database.name
+        )
+
+
+class DatabaseDropItemDropOutcome(OutcomeInterface):
+    """Represents outcome."""
+
+    def __init__(self, *, database: Database) -> None:
+        """Set attributes."""
+        self.database = database
+
+    def __str__(self) -> str:
+        """Get human-readable string."""
+        return f"Drop {self.database.name} in {self.database.server_software_name}"
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, DatabaseDropItemDropOutcome):
+            return False
+
+        return (
+            other.database.server_software_name == self.database.server_software_name
+            and other.database.name == self.database.name
+        )
+
+
+class DatabaseUserEnsureStateItemCreateOutcome(OutcomeInterface):
+    """Represents outcome."""
+
+    def __init__(self, *, database_user: DatabaseUser) -> None:
+        """Set attributes."""
+        self.database_user = database_user
+
+    def __str__(self) -> str:
+        """Get human-readable string."""
+        return f"Create {self.database_user.name} in {self.database_user.server_software_name}"
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, DatabaseUserEnsureStateItemCreateOutcome):
+            return False
+
+        return (
+            other.database_user.server_software_name
+            == self.database_user.server_software_name
+            and other.database_user.name == self.database_user.name
+            and other.database_user.password == self.database_user.password
+            and other.database_user.host == self.database_user.host
+        )
+
+
+class DatabaseUserEnsureStateItemEditPasswordOutcome(OutcomeInterface):
+    """Represents outcome."""
+
+    def __init__(self, *, database_user: DatabaseUser) -> None:
+        """Set attributes."""
+        self.database_user = database_user
+
+    def __str__(self) -> str:
+        """Get human-readable string."""
+        return f"Edit password of {self.database_user.name} in {self.database_user.server_software_name}"
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, DatabaseUserEnsureStateItemEditPasswordOutcome):
+            return False
+
+        print(
+            other.database_user.server_software_name,
+            other.database_user.name,
+            other.database_user.password,
+            other.database_user.host,
+        )
+        print(
+            self.database_user.server_software_name,
+            self.database_user.name,
+            self.database_user.password,
+            self.database_user.host,
+        )
+
+        return (
+            other.database_user.server_software_name
+            == self.database_user.server_software_name
+            and other.database_user.name == self.database_user.name
+            and other.database_user.password == self.database_user.password
+            and other.database_user.host == self.database_user.host
+        )
+
+
+class DatabaseUserDropItemDropOutcome(OutcomeInterface):
+    """Represents outcome."""
+
+    def __init__(self, *, database_user: DatabaseUser) -> None:
+        """Set attributes."""
+        self.database_user = database_user
+
+    def __str__(self) -> str:
+        """Get human-readable string."""
+        return f"Drop {self.database_user.name} in {self.database_user.server_software_name}"
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, DatabaseUserDropItemDropOutcome):
+            return False
+
+        return (
+            other.database_user.server_software_name
+            == self.database_user.server_software_name
+            and other.database_user.name == self.database_user.name
+            and other.database_user.host == self.database_user.host
+        )
+
+
+class DatabaseUserGrantGrantItemGrantOutcome(OutcomeInterface):
+    """Represents outcome."""
+
+    def __init__(self, *, database_user_grant: DatabaseUserGrant) -> None:
+        """Set attributes."""
+        self.database_user_grant = database_user_grant
+
+    def __str__(self) -> str:
+        """Get human-readable string."""
+        return f"Grant {self.database_user_grant.privilege_names} to {self.database_user_grant.table_name} in {self.database_user_grant.database_name} in {self.database_user_grant.database_user.server_software_name}"
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, DatabaseUserGrantGrantItemGrantOutcome):
+            return False
+
+        return (
+            other.database_user_grant.database_user.server_software_name
+            == self.database_user_grant.database_user.server_software_name
+            and other.database_user_grant.database_user.name
+            == self.database_user_grant.database_user.name
+            and other.database_user_grant.database_user.host
+            == self.database_user_grant.database_user.host
+            and other.database_user_grant.privilege_names
+            == self.database_user_grant.privilege_names
+            and other.database_user_grant.table_name
+            == self.database_user_grant.table_name
+        )
+
+
+class DatabaseUserGrantRevokeItemRevokeOutcome(OutcomeInterface):
+    """Represents outcome."""
+
+    def __init__(self, *, database_user_grant: DatabaseUserGrant) -> None:
+        """Set attributes."""
+        self.database_user_grant = database_user_grant
+
+    def __str__(self) -> str:
+        """Get human-readable string."""
+        return f"Revoke {self.database_user_grant.privilege_names} to {self.database_user_grant.table_name} in {self.database_user_grant.database_name} in {self.database_user_grant.database_user.server_software_name}"
+
+    def __eq__(self, other: object) -> bool:
+        """Get equality based on attributes."""
+        if not isinstance(other, DatabaseUserGrantRevokeItemRevokeOutcome):
+            return False
+
+        return (
+            other.database_user_grant.database_user.server_software_name
+            == self.database_user_grant.database_user.server_software_name
+            and other.database_user_grant.database_user.name
+            == self.database_user_grant.database_user.name
+            and other.database_user_grant.database_user.host
+            == self.database_user_grant.database_user.host
+            and other.database_user_grant.privilege_names
+            == self.database_user_grant.privilege_names
+            and other.database_user_grant.table_name
+            == self.database_user_grant.table_name
+        )

python3_cyberfusion_queue_support-2.2.1/src/cyberfusion/QueueSupport/settings.py

@@ -0,0 +1,13 @@
+from pydantic import BaseSettings
+
+
+class Settings(BaseSettings):
+    database_path: str = "sqlite:///./queue-support.db"
+
+    class Config:
+        env_prefix = "queue_support_"
+
+        env_file = ".env", "/etc/queue-support.conf"
+
+
+settings = Settings()

{python3_cyberfusion_queue_support-2.0 → python3_cyberfusion_queue_support-2.2.1}/src/python3_cyberfusion_queue_support.egg-info/PKG-INFO

@@ -1,13 +1,15 @@
 Metadata-Version: 2.4
 Name: python3-cyberfusion-queue-support
-Version: 2.0
+Version: 2.2.1
 Summary: Library to queue actions.
 Author-email: Cyberfusion <support@cyberfusion.io>
 Project-URL: Source, https://github.com/CyberfusionIO/python3-cyberfusion-queue-support
 Description-Content-Type: text/markdown
 Requires-Dist: python3-cyberfusion-systemd-support~=2.1
+Requires-Dist: python3-cyberfusion-database-support~=3.0
 Requires-Dist: alembic==1.8.1
 Requires-Dist: SQLAlchemy==1.4.46
+Requires-Dist: pydantic[dotenv]==1.10.4
 
 # python3-cyberfusion-queue-support
 
@@ -48,6 +50,10 @@ Run the following command to install the package from PyPI:
 
     pip3 install python3-cyberfusion-queue-support
 
+Then, run database migrations:
+
+    bin/queue-support-migrate
+
 ## Debian
 
 Run the following commands to build a Debian package:

{python3_cyberfusion_queue_support-2.0 → python3_cyberfusion_queue_support-2.2.1}/src/python3_cyberfusion_queue_support.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ src/cyberfusion/QueueSupport/__init__.py
 src/cyberfusion/QueueSupport/database.py
 src/cyberfusion/QueueSupport/interfaces.py
 src/cyberfusion/QueueSupport/outcomes.py
+src/cyberfusion/QueueSupport/settings.py
 src/cyberfusion/QueueSupport/utilities.py
 src/cyberfusion/QueueSupport/exceptions/__init__.py
 src/cyberfusion/QueueSupport/items/__init__.py
@@ -12,6 +13,12 @@ src/cyberfusion/QueueSupport/items/chmod.py
 src/cyberfusion/QueueSupport/items/chown.py
 src/cyberfusion/QueueSupport/items/command.py
 src/cyberfusion/QueueSupport/items/copy.py
+src/cyberfusion/QueueSupport/items/database_create.py
+src/cyberfusion/QueueSupport/items/database_drop.py
+src/cyberfusion/QueueSupport/items/database_user_drop.py
+src/cyberfusion/QueueSupport/items/database_user_ensure_state.py
+src/cyberfusion/QueueSupport/items/database_user_grant_grant.py
+src/cyberfusion/QueueSupport/items/database_user_grant_revoke.py
 src/cyberfusion/QueueSupport/items/mkdir.py
 src/cyberfusion/QueueSupport/items/move.py
 src/cyberfusion/QueueSupport/items/rmtree.py
@@ -24,8 +31,13 @@ src/cyberfusion/QueueSupport/items/systemd_unit_restart.py
 src/cyberfusion/QueueSupport/items/systemd_unit_start.py
 src/cyberfusion/QueueSupport/items/systemd_unit_stop.py
 src/cyberfusion/QueueSupport/items/unlink.py
+src/cyberfusion/QueueSupport/migrations/__init__.py
+src/cyberfusion/QueueSupport/migrations/env.py
+src/cyberfusion/QueueSupport/migrations/versions/571e55ab5ed5_initial_migration.py
+src/cyberfusion/QueueSupport/migrations/versions/__init__.py
 src/python3_cyberfusion_queue_support.egg-info/PKG-INFO
 src/python3_cyberfusion_queue_support.egg-info/SOURCES.txt
 src/python3_cyberfusion_queue_support.egg-info/dependency_links.txt
+src/python3_cyberfusion_queue_support.egg-info/entry_points.txt
 src/python3_cyberfusion_queue_support.egg-info/requires.txt
 src/python3_cyberfusion_queue_support.egg-info/top_level.txt

python3_cyberfusion_queue_support-2.2.1/src/python3_cyberfusion_queue_support.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+queue-support-migrate = cyberfusion.QueueSupport.database:run_migrations

{python3_cyberfusion_queue_support-2.0 → python3_cyberfusion_queue_support-2.2.1}/src/python3_cyberfusion_queue_support.egg-info/requires.txt

@@ -1,3 +1,5 @@
 python3-cyberfusion-systemd-support~=2.1
+python3-cyberfusion-database-support~=3.0
 alembic==1.8.1
 SQLAlchemy==1.4.46
+pydantic[dotenv]==1.10.4