Add SQLite database integration with SQLAlchemy async, migration tooling, and comprehensive CRUD operations for hosts, tasks, schedules, and logs

2025-12-04 21:37:55 -05:00
parent 28276f326b
commit ad3a8a5639
38 changed files with 2503 additions and 388 deletions
@@ -0,0 +1,17 @@
+from .database import Base
+from .host import Host
+from .bootstrap_status import BootstrapStatus
+from .task import Task
+from .schedule import Schedule
+from .schedule_run import ScheduleRun
+from .log import Log
+
+__all__ = [
+    "Base",
+    "Host",
+    "BootstrapStatus",
+    "Task",
+    "Schedule",
+    "ScheduleRun",
+    "Log",
+]
@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Optional
+
+from sqlalchemy import DateTime, ForeignKey, Integer, String, Text
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.sql import func
+
+from .database import Base
+
+
+class BootstrapStatus(Base):
+    __tablename__ = "bootstrap_status"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    host_id: Mapped[str] = mapped_column(String, ForeignKey("hosts.id", ondelete="CASCADE"), nullable=False)
+    status: Mapped[str] = mapped_column(String, nullable=False)
+    automation_user: Mapped[Optional[str]] = mapped_column(String, nullable=True)
+    last_attempt: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True))
+    error_message: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
+
+    host: Mapped["Host"] = relationship("Host", back_populates="bootstrap_statuses")
+
+    def __repr__(self) -> str:  # pragma: no cover - debug helper
+        return f"<BootstrapStatus id={self.id} host_id={self.host_id} status={self.status}>"
@@ -0,0 +1,106 @@
+"""Database configuration and session management for Homelab Automation.
+Uses SQLAlchemy 2.x async engine with SQLite + aiosqlite driver.
+"""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import AsyncGenerator
+from urllib.parse import urlparse
+
+from sqlalchemy import event, MetaData
+from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_sessionmaker, create_async_engine
+from sqlalchemy.orm import declarative_base
+
+# Naming convention to keep Alembic happy with constraints
+NAMING_CONVENTION = {
+    "ix": "ix_%(column_0_label)s",
+    "uq": "uq_%(table_name)s_%(column_0_name)s",
+    "ck": "ck_%(table_name)s_%(constraint_name)s",
+    "fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
+    "pk": "pk_%(table_name)s",
+}
+
+metadata_obj = MetaData(naming_convention=NAMING_CONVENTION)
+Base = declarative_base(metadata=metadata_obj)
+
+# Resolve base path (project root)
+ROOT_DIR = Path(__file__).resolve().parents[2]
+DEFAULT_DB_PATH = Path(os.environ.get("DB_PATH") or (ROOT_DIR / "data" / "homelab.db"))
+DATABASE_URL = os.environ.get("DATABASE_URL", f"sqlite+aiosqlite:///{DEFAULT_DB_PATH}")
+
+# Ensure SQLite directory exists even if DATABASE_URL overrides DB_PATH
+def _ensure_sqlite_dir(db_url: str) -> None:
+    if not db_url.startswith("sqlite"):
+        return
+    parsed = urlparse(db_url.replace("sqlite+aiosqlite", "sqlite"))
+    if parsed.scheme != "sqlite":
+        return
+    db_path = Path(parsed.path)
+    if db_path.parent:
+        db_path.parent.mkdir(parents=True, exist_ok=True)
+
+DEFAULT_DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+_ensure_sqlite_dir(DATABASE_URL)
+
+
+def _debug_db_paths() -> None:
+    try:
+        print(
+            "[DB] DATABASE_URL=%s, DEFAULT_DB_PATH=%s, parent_exists=%s, parent=%s"
+            % (
+                DATABASE_URL,
+                DEFAULT_DB_PATH,
+                DEFAULT_DB_PATH.parent.exists(),
+                DEFAULT_DB_PATH.parent,
+            )
+        )
+    except Exception:
+        # Debug logging should never break startup
+        pass
+
+
+_debug_db_paths()
+
+engine: AsyncEngine = create_async_engine(
+    DATABASE_URL,
+    echo=False,
+    pool_pre_ping=True,
+    future=True,
+)
+
+# Ensure SQLite pragmas (WAL + FK) when using SQLite
+if DATABASE_URL.startswith("sqlite"):
+    @event.listens_for(engine.sync_engine, "connect")
+    def _set_sqlite_pragmas(dbapi_connection, connection_record):  # type: ignore[override]
+        cursor = dbapi_connection.cursor()
+        cursor.execute("PRAGMA foreign_keys=ON")
+        cursor.execute("PRAGMA journal_mode=WAL")
+        cursor.close()
+
+async_session_maker = async_sessionmaker(
+    bind=engine,
+    autoflush=False,
+    expire_on_commit=False,
+    class_=AsyncSession,
+)
+
+
+async def get_db() -> AsyncGenerator[AsyncSession, None]:
+    """FastAPI dependency that yields an AsyncSession with automatic rollback on error."""
+    async with async_session_maker() as session:  # type: AsyncSession
+        try:
+            yield session
+        except Exception:
+            await session.rollback()
+            raise
+        finally:
+            await session.close()
+
+
+async def init_db() -> None:
+    """Create all tables (mostly for dev/tests; migrations should be handled by Alembic)."""
+    from . import host, task, schedule, schedule_run, log  # noqa: F401
+
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import List, Optional
+
+from sqlalchemy import Boolean, DateTime, String, text
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.sql import func
+
+from .database import Base
+
+
+class Host(Base):
+    __tablename__ = "hosts"
+
+    id: Mapped[str] = mapped_column(String, primary_key=True)
+    name: Mapped[str] = mapped_column(String, nullable=False)
+    ip_address: Mapped[str] = mapped_column(String, nullable=False, unique=True)
+    status: Mapped[str] = mapped_column(String, nullable=False, server_default=text("'unknown'"))
+    ansible_group: Mapped[Optional[str]] = mapped_column(String, nullable=True)
+    last_seen: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True))
+    reachable: Mapped[bool] = mapped_column(Boolean, nullable=False, server_default=text("0"))
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
+    updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now(), onupdate=func.now())
+    deleted_at: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True))
+
+    bootstrap_statuses: Mapped[List["BootstrapStatus"]] = relationship(
+        "BootstrapStatus", back_populates="host", cascade="all, delete-orphan"
+    )
+    logs: Mapped[List["Log"]] = relationship("Log", back_populates="host")
+
+    def __repr__(self) -> str:  # pragma: no cover - debug helper
+        return f"<Host id={self.id} name={self.name} ip={self.ip_address}>"
@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Optional
+
+from sqlalchemy import DateTime, ForeignKey, Integer, JSON, String, Text, Index
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.sql import func
+
+from .database import Base
+
+
+class Log(Base):
+    __tablename__ = "logs"
+    __table_args__ = (
+        Index("idx_logs_created_at", "created_at"),
+        Index("idx_logs_level", "level"),
+        Index("idx_logs_source", "source"),
+    )
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    level: Mapped[str] = mapped_column(String, nullable=False)
+    source: Mapped[Optional[str]] = mapped_column(String)
+    message: Mapped[str] = mapped_column(Text, nullable=False)
+    details: Mapped[Optional[dict]] = mapped_column(JSON)
+    host_id: Mapped[Optional[str]] = mapped_column(String, ForeignKey("hosts.id", ondelete="SET NULL"))
+    task_id: Mapped[Optional[str]] = mapped_column(String, ForeignKey("tasks.id", ondelete="SET NULL"))
+    schedule_id: Mapped[Optional[str]] = mapped_column(String, ForeignKey("schedules.id", ondelete="SET NULL"))
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
+
+    host: Mapped[Optional["Host"]] = relationship("Host", back_populates="logs")
+    task: Mapped[Optional["Task"]] = relationship("Task", back_populates="logs")
+    schedule: Mapped[Optional["Schedule"]] = relationship("Schedule", back_populates="logs")
+
+    def __repr__(self) -> str:  # pragma: no cover - debug helper
+        return f"<Log id={self.id} level={self.level} source={self.source}>"
@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import List, Optional
+
+from sqlalchemy import Boolean, DateTime, String, Text
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.sql import func
+
+from .database import Base
+
+
+class Schedule(Base):
+    __tablename__ = "schedules"
+
+    id: Mapped[str] = mapped_column(String, primary_key=True)
+    name: Mapped[str] = mapped_column(String, nullable=False)
+    playbook: Mapped[str] = mapped_column(String, nullable=False)
+    target: Mapped[str] = mapped_column(String, nullable=False)
+    schedule_type: Mapped[str] = mapped_column(String, nullable=False)
+    schedule_time: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True))
+    recurrence_type: Mapped[Optional[str]] = mapped_column(String)
+    recurrence_time: Mapped[Optional[str]] = mapped_column(String)
+    recurrence_days: Mapped[Optional[str]] = mapped_column(Text)
+    cron_expression: Mapped[Optional[str]] = mapped_column(String)
+    enabled: Mapped[bool] = mapped_column(Boolean, nullable=False, default=True)
+    tags: Mapped[Optional[str]] = mapped_column(Text)
+    next_run: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True))
+    last_run: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True))
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
+    updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now(), onupdate=func.now())
+    deleted_at: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True))
+
+    runs: Mapped[List["ScheduleRun"]] = relationship(
+        "ScheduleRun", back_populates="schedule", cascade="all, delete-orphan"
+    )
+    logs: Mapped[List["Log"]] = relationship("Log", back_populates="schedule")
+
+    def __repr__(self) -> str:  # pragma: no cover - debug helper
+        return f"<Schedule id={self.id} name={self.name} target={self.target}>"
@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Optional
+
+from sqlalchemy import DateTime, ForeignKey, Integer, String, Text, Float
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.sql import func
+
+from .database import Base
+
+
+class ScheduleRun(Base):
+    __tablename__ = "schedule_runs"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    schedule_id: Mapped[str] = mapped_column(String, ForeignKey("schedules.id", ondelete="CASCADE"), nullable=False)
+    task_id: Mapped[Optional[str]] = mapped_column(String, ForeignKey("tasks.id", ondelete="SET NULL"))
+    status: Mapped[str] = mapped_column(String, nullable=False)
+    started_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
+    completed_at: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True))
+    duration: Mapped[Optional[float]] = mapped_column(Float)
+    error_message: Mapped[Optional[str]] = mapped_column(Text)
+    output: Mapped[Optional[str]] = mapped_column(Text)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
+
+    schedule: Mapped["Schedule"] = relationship("Schedule", back_populates="runs")
+    task: Mapped[Optional["Task"]] = relationship("Task", back_populates="schedule_runs")
+
+    def __repr__(self) -> str:  # pragma: no cover - debug helper
+        return f"<ScheduleRun id={self.id} schedule_id={self.schedule_id} status={self.status}>"
@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Optional
+
+from sqlalchemy import DateTime, ForeignKey, String, Text, JSON, text
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.sql import func
+
+from .database import Base
+
+
+class Task(Base):
+    __tablename__ = "tasks"
+
+    id: Mapped[str] = mapped_column(String, primary_key=True)
+    action: Mapped[str] = mapped_column(String, nullable=False)
+    target: Mapped[str] = mapped_column(String, nullable=False)
+    status: Mapped[str] = mapped_column(String, nullable=False, server_default=text("'pending'"))
+    playbook: Mapped[Optional[str]] = mapped_column(String)
+    started_at: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True))
+    completed_at: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True))
+    error_message: Mapped[Optional[str]] = mapped_column(Text)
+    result_data: Mapped[Optional[dict]] = mapped_column(JSON)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
+
+    schedule_runs: Mapped[list["ScheduleRun"]] = relationship("ScheduleRun", back_populates="task")
+    logs: Mapped[list["Log"]] = relationship("Log", back_populates="task")
+
+    def __repr__(self) -> str:  # pragma: no cover - debug helper
+        return f"<Task id={self.id} action={self.action} target={self.target} status={self.status}>"