octopize.deploy_tool 0.1.0__py3-none-any.whl

octopize_avatar_deploy/printer.py

@@ -0,0 +1,216 @@
+#!/usr/bin/env python3
+"""
+Output printer abstraction for deployment tool.
+
+Provides a pluggable interface for customizing output behavior
+(console, file, GUI, etc.) without modifying core logic.
+"""
+
+from pathlib import Path
+from typing import Protocol
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+
+class Printer(Protocol):
+    """Protocol for output printing."""
+
+    def print(self, message: str = "") -> None:
+        """Print a regular message."""
+        ...
+
+    def print_header(self, title: str, width: int = 60) -> None:
+        """Print a section header."""
+        ...
+
+    def print_success(self, message: str) -> None:
+        """Print a success message."""
+        ...
+
+    def print_error(self, message: str) -> None:
+        """Print an error message."""
+        ...
+
+    def print_warning(self, message: str) -> None:
+        """Print a warning message."""
+        ...
+
+    def print_step(self, description: str, skipped: bool = False) -> None:
+        """Print a step header."""
+        ...
+
+
+class ConsolePrinter:
+    """Default console-based printer implementation."""
+
+    def print(self, message: str = "") -> None:
+        """Print a regular message to console."""
+        print(message)
+
+    def print_header(self, title: str, width: int = 60) -> None:
+        """Print a formatted section header."""
+        self.print("\n" + "=" * width)
+        self.print(title)
+        self.print("=" * width)
+
+    def print_success(self, message: str) -> None:
+        """Print a success message with checkmark."""
+        self.print(f"✓ {message}")
+
+    def print_error(self, message: str) -> None:
+        """Print an error message with X symbol."""
+        self.print(f"✗ {message}")
+
+    def print_warning(self, message: str) -> None:
+        """Print a warning message with warning symbol."""
+        self.print(f"⚠ {message}")
+
+    def print_step(self, description: str, skipped: bool = False) -> None:
+        """Print a step header with optional skipped indicator."""
+        if skipped:
+            self.print(f"\n--- {description} [SKIPPED - already completed] ---")
+        else:
+            self.print(f"\n--- {description} ---")
+
+
+class SilentPrinter:
+    """Silent printer that suppresses all output."""
+
+    def print(self, message: str = "") -> None:
+        """Do nothing."""
+        pass
+
+    def print_header(self, title: str, width: int = 60) -> None:
+        """Do nothing."""
+        pass
+
+    def print_success(self, message: str) -> None:
+        """Do nothing."""
+        pass
+
+    def print_error(self, message: str) -> None:
+        """Do nothing."""
+        pass
+
+    def print_warning(self, message: str) -> None:
+        """Do nothing."""
+        pass
+
+    def print_step(self, description: str, skipped: bool = False) -> None:
+        """Do nothing."""
+        pass
+
+
+class RichPrinter:
+    """
+    Rich-based printer with enhanced formatting and colors.
+
+    Uses the 'rich' library to provide beautiful console output with:
+    - Colors and styles
+    - Panels and boxes
+    - Better formatting
+    """
+
+    def __init__(self):
+        """Initialize RichPrinter with a Console instance."""
+        self.console = Console()
+
+    def print(self, message: str = "") -> None:
+        """Print a regular message to console."""
+        self.console.print(message)
+
+    def print_header(self, title: str, width: int = 60) -> None:
+        """Print a formatted section header with panel."""
+        if title:
+            panel = Panel(
+                Text(title, style="bold cyan", justify="center"),
+                border_style="cyan",
+                padding=(0, 2),
+            )
+            self.console.print()
+            self.console.print(panel)
+        else:
+            self.console.print()
+
+    def print_success(self, message: str) -> None:
+        """Print a success message with green checkmark."""
+        self.console.print(f"[green]✓[/green] {message}")
+
+    def print_error(self, message: str) -> None:
+        """Print an error message with red X symbol."""
+        self.console.print(f"[red]✗[/red] {message}")
+
+    def print_warning(self, message: str) -> None:
+        """Print a warning message with yellow warning symbol."""
+        self.console.print(f"[yellow]⚠[/yellow] {message}")
+
+    def print_step(self, description: str, skipped: bool = False) -> None:
+        """Print a step header with optional skipped indicator."""
+        self.console.print()
+        if skipped:
+            self.console.print(f"[dim]--- {description} [SKIPPED - already completed] ---[/dim]")
+        else:
+            self.console.print(f"[bold blue]--- {description} ---[/bold blue]")
+
+
+class FilePrinter:
+    """
+    File-based printer that writes all output to a log file.
+
+    Useful for test debugging - when tests fail, you can inspect
+    the log file to see what happened.
+    """
+
+    def __init__(self, log_file: Path | str, append: bool = False):
+        """
+        Initialize FilePrinter.
+
+        Args:
+            log_file: Path to log file
+            append: Whether to append to existing file (default: False, overwrite)
+        """
+        self.log_file = Path(log_file)
+        self.mode = "a" if append else "w"
+
+        # Create parent directory if needed
+        self.log_file.parent.mkdir(parents=True, exist_ok=True)
+
+        # Clear file if not appending
+        if not append:
+            self.log_file.write_text("")
+
+    def _write(self, message: str) -> None:
+        """Write message to log file."""
+        with open(self.log_file, "a") as f:
+            f.write(message + "\n")
+
+    def print(self, message: str = "") -> None:
+        """Print a regular message to file."""
+        self._write(message)
+
+    def print_header(self, title: str, width: int = 60) -> None:
+        """Print a formatted section header to file."""
+        self._write("\n" + "=" * width)
+        self._write(title)
+        self._write("=" * width)
+
+    def print_success(self, message: str) -> None:
+        """Print a success message to file."""
+        self._write(f"✓ {message}")
+
+    def print_error(self, message: str) -> None:
+        """Print an error message to file."""
+        self._write(f"✗ {message}")
+
+    def print_warning(self, message: str) -> None:
+        """Print a warning message to file."""
+        self._write(f"⚠ {message}")
+
+    def print_step(self, description: str, skipped: bool = False) -> None:
+        """Print a step header to file."""
+        if skipped:
+            self._write(f"\n--- {description} [SKIPPED - already completed] ---")
+        else:
+            self._write(f"\n--- {description} ---")

octopize_avatar_deploy/state_manager.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+"""
+State Manager for Avatar Deployment Configuration
+
+Manages deployment configuration state to support resuming interrupted configurations.
+"""
+
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+
+class DeploymentState:
+    """Manages the state of a deployment configuration."""
+
+    def __init__(self, state_file: Path, steps: list[str]):
+        """
+        Initialize the state manager.
+
+        Args:
+            state_file: Path to the state file
+            steps: List of step names to track. If None, uses DEFAULT_STEPS
+        """
+        self.state_file = state_file
+        self.steps = steps
+        self.state = self._load_state()
+
+    def _load_state(self) -> dict[str, Any]:
+        """Load state from file or create new state."""
+        if self.state_file.exists():
+            with open(self.state_file) as f:
+                return yaml.safe_load(f) or self._create_initial_state()
+        return self._create_initial_state()
+
+    def _create_initial_state(self) -> dict[str, Any]:
+        """Create initial state structure."""
+        return {
+            "version": "1.0",
+            "steps": dict.fromkeys(self.steps, "not-started"),
+            "config": {},
+            "step_data": {},  # Store step-specific data
+            "user_secrets_provided": {},  # Track which user secrets were provided
+        }
+
+    def save(self) -> None:
+        """Save current state to file."""
+        self.state_file.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.state_file, "w") as f:
+            yaml.dump(self.state, f, default_flow_style=False, sort_keys=False)
+
+    def get_step_status(self, step: str) -> str:
+        """Get the status of a step."""
+        return self.state["steps"].get(step, "not-started")
+
+    def mark_step_started(self, step: str) -> None:
+        """Mark a step as in-progress."""
+        self.state["steps"][step] = "in-progress"
+        self.save()
+
+    def mark_step_completed(self, step: str) -> None:
+        """Mark a step as completed."""
+        self.state["steps"][step] = "completed"
+        self.save()
+
+    def is_step_completed(self, step: str) -> bool:
+        """Check if a step is completed."""
+        return self.get_step_status(step) == "completed"
+
+    def get_next_step(self) -> str | None:
+        """Get the next step that needs to be executed."""
+        for step in self.steps:
+            if not self.is_step_completed(step):
+                return step
+        return None
+
+    def update_config(self, config: dict[str, Any]) -> None:
+        """Update configuration in state."""
+        self.state["config"].update(config)
+        self.save()
+
+    def get_config(self) -> dict[str, Any]:
+        """Get current configuration from state."""
+        return self.state["config"].copy()
+
+    def mark_user_secret_provided(self, secret_name: str, provided: bool = True) -> None:
+        """Mark whether a user secret was provided."""
+        self.state["user_secrets_provided"][secret_name] = provided
+        self.save()
+
+    def is_user_secret_provided(self, secret_name: str) -> bool:
+        """Check if a user secret was provided."""
+        return self.state["user_secrets_provided"].get(secret_name, False)
+
+    def reset(self) -> None:
+        """Reset state to initial values."""
+        self.state = self._create_initial_state()
+        self.save()
+
+    def delete(self) -> None:
+        """Delete the state file."""
+        if self.state_file.exists():
+            self.state_file.unlink()
+
+    def has_started(self) -> bool:
+        """Check if any configuration has been started."""
+        return any(status != "not-started" for status in self.state["steps"].values())
+
+    def is_complete(self) -> bool:
+        """Check if all steps are completed."""
+        return all(status == "completed" for status in self.state["steps"].values())
+
+    def get_progress_summary(self) -> str:
+        """Get a human-readable progress summary."""
+        completed = sum(1 for s in self.state["steps"].values() if s == "completed")
+        total = len(self.steps)
+        return f"{completed}/{total} steps completed"
+
+    def print_status(self) -> None:
+        """Print current status."""
+        print("\n" + "=" * 60)
+        print("Deployment Configuration Status")
+        print("=" * 60)
+        print(f"\n{self.get_progress_summary()}\n")
+
+        for step in self.steps:
+            status = self.get_step_status(step)
+            icon = "✓" if status == "completed" else "○" if status == "not-started" else "◐"
+            print(f"  {icon} {step.replace('_', ' ').title()}: {status}")
+
+        if self.is_complete():
+            print("\n✓ Configuration is complete!")
+        elif self.has_started():
+            next_step = self.get_next_step()
+            if next_step:
+                print(f"\n→ Next step: {next_step.replace('_', ' ').title()}")

octopize_avatar_deploy/steps/__init__.py

@@ -0,0 +1,25 @@
+"""Deployment configuration steps."""
+
+from .authentik import AuthentikStep
+from .authentik_blueprint import AuthentikBlueprintStep
+from .base import DeploymentStep
+from .database import DatabaseStep
+from .email import EmailStep
+from .logging import LoggingStep
+from .required import RequiredConfigStep
+from .storage import StorageStep
+from .telemetry import TelemetryStep
+from .user import UserStep
+
+__all__ = [
+    "DeploymentStep",
+    "RequiredConfigStep",
+    "EmailStep",
+    "TelemetryStep",
+    "LoggingStep",
+    "DatabaseStep",
+    "StorageStep",
+    "AuthentikStep",
+    "AuthentikBlueprintStep",
+    "UserStep",
+]

octopize_avatar_deploy/steps/authentik.py

@@ -0,0 +1,46 @@
+"""Authentik configuration step."""
+
+import secrets
+from typing import Any
+
+from .base import DeploymentStep
+
+
+class AuthentikStep(DeploymentStep):
+    """Handles Authentik SSO configuration and credentials."""
+
+    name = "authentik"
+    description = "Configure Authentik SSO authentication credentials"
+    required = True
+
+    def collect_config(self) -> dict[str, Any]:
+        """Collect Authentik configuration."""
+        config = {}
+
+        # Authentik database name and user
+        # These are typically set to default values unless customized
+        authentik_db_name = self.config.get(
+            "AUTHENTIK_DATABASE_NAME",
+            "authentik",
+        )
+        authentik_db_user = self.config.get(
+            "AUTHENTIK_DATABASE_USER",
+            "authentik",
+        )
+
+        config["AUTHENTIK_DATABASE_NAME"] = authentik_db_name
+        config["AUTHENTIK_DATABASE_USER"] = authentik_db_user
+
+        # Update self.config so generate_secrets() can access these values
+        self.config.update(config)
+
+        return config
+
+    def generate_secrets(self) -> dict[str, str]:
+        """Generate Authentik-related secrets."""
+        return {
+            "authentik_database_name": self.config["AUTHENTIK_DATABASE_NAME"],
+            "authentik_database_user": self.config["AUTHENTIK_DATABASE_USER"],
+            "authentik_database_password": secrets.token_hex(),
+            "authentik_secret_key": secrets.token_hex(),
+        }

octopize_avatar_deploy/steps/authentik_blueprint.py

@@ -0,0 +1,79 @@
+"""Authentik blueprint configuration step."""
+
+import secrets
+from typing import Any
+
+from .base import DeploymentStep
+
+
+class AuthentikBlueprintStep(DeploymentStep):
+    """Handles Authentik blueprint configuration for SSO setup.
+
+    The blueprint template (octopize-avatar-blueprint.yaml) is stored in
+    docker/templates/authentik/ and will be populated with these values.
+
+    This step derives all values from existing configuration without prompting:
+    - Domain from PUBLIC_URL
+    - Random OAuth2 client ID
+    - Redirect URI from domain
+    - Default license type
+    """
+
+    name = "authentik-blueprint"
+    description = "Configure Authentik SSO blueprint settings"
+    required = True
+
+    def collect_config(self) -> dict[str, Any]:
+        """Collect Authentik blueprint configuration.
+
+        All values are derived from existing config without user prompts.
+        """
+        config = {}
+
+        # Extract domain from PUBLIC_URL (required config value)
+        public_url = self.config.get("PUBLIC_URL", "")
+        # Remove protocol and trailing slashes
+        domain = public_url.replace("https://", "").replace("http://", "").rstrip("/")
+
+        # Ensure domain is not empty
+        if not domain:
+            raise ValueError(
+                f"PUBLIC_URL '{public_url}' is not set or invalid; cannot derive BLUEPRINT_DOMAIN."
+            )
+
+        config["BLUEPRINT_DOMAIN"] = domain
+
+        # Generate random OAuth2 client ID (or use existing if provided)
+        client_id = self.config.get("BLUEPRINT_CLIENT_ID", secrets.token_hex(32))
+        config["BLUEPRINT_CLIENT_ID"] = client_id
+
+        # Generate OAuth2 client secret (or use existing if provided)
+        # This is a config value because it goes directly into the blueprint template
+        client_secret = self.config.get("BLUEPRINT_CLIENT_SECRET", secrets.token_hex(32))
+        config["BLUEPRINT_CLIENT_SECRET"] = client_secret
+
+        # Build API redirect URI from domain
+        redirect_uri = self.config.get(
+            "BLUEPRINT_API_REDIRECT_URI", f"https://{domain}/api/login/sso/auth"
+        )
+        config["BLUEPRINT_API_REDIRECT_URI"] = redirect_uri
+
+        # Use default license type (or from config)
+        license_type = self.config.get(
+            "BLUEPRINT_SELF_SERVICE_LICENSE",
+            "demo",  # Default to demo license
+        )
+        config["BLUEPRINT_SELF_SERVICE_LICENSE"] = license_type
+
+        # Update self.config for generate_secrets()
+        self.config.update(config)
+
+        return config
+
+    def generate_secrets(self) -> dict[str, str]:
+        """Generate Authentik blueprint secrets.
+
+        The blueprint step doesn't generate any docker secrets.
+        All values are stored as config values instead.
+        """
+        return {}