octopize.deploy_tool 0.1.0__py3-none-any.whl

octopize_avatar_deploy/defaults.yaml

@@ -0,0 +1,63 @@
+# Default Configuration Values for Avatar Deployment
+# Version: 1.0.0 (MAJOR.MINOR.PATCH)
+# Compatible with script version: >=1.0.0,<2.0.0
+
+version: "1.0.0"
+
+# Image versions - updated regularly with new releases
+images:
+  api: "2.20.1"
+  web: "0.40.0"
+  pdfgenerator: "latest"
+  seaweedfs: "0.2.0"
+  authentik: "2025.10.2"
+
+# Email configuration defaults
+email:
+  provider: "aws"  # 'aws' or 'smtp'
+  smtp:
+    host: "email-smtp.eu-west-3.amazonaws.com"
+    port: "587"
+    use_tls: "true"
+    start_tls: "false"
+    verify: "true"
+    sender_email: "noreply@octopize.io"
+
+# Telemetry configuration (for usage analytics)
+telemetry:
+  enabled: true  # Ask user if they want to enable telemetry
+  endpoint_url: "https://s3.fr-par.scw.cloud"
+  region: "fr-par"
+
+# Application settings (defaults when no preset is selected)
+application:
+  use_console_logging: "false"
+  log_level: "INFO"
+  sentry_enabled: "true"
+  email_authentication: "true"
+
+# Deployment presets - pre-configured settings for common scenarios
+presets:
+  default:
+    description: "Production-ready configuration with telemetry and monitoring"
+    application:
+      use_console_logging: "false"
+      sentry_enabled: "true"
+    telemetry:
+      enabled: true
+
+  dev-mode:
+    description: "Development mode with console logging, no external services"
+    application:
+      use_console_logging: "true"
+      sentry_enabled: "false"
+    telemetry:
+      enabled: false
+
+  airgapped:
+    description: "Air-gapped deployment without external monitoring or telemetry"
+    application:
+      use_console_logging: "false"
+      sentry_enabled: "false"
+    telemetry:
+      enabled: false

octopize_avatar_deploy/download_templates.py

@@ -0,0 +1,251 @@
+"""
+Provide deployment templates from various sources.
+
+This module handles obtaining necessary template files either from GitHub
+or from a local directory (for testing).
+"""
+
+import shutil
+import urllib.request
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+# GitHub raw content URL base
+GITHUB_RAW_BASE = "https://raw.githubusercontent.com/octopize/avatar-deployment"
+DEFAULT_BRANCH = "main"
+
+# Files to download from the docker/templates/ directory
+REQUIRED_FILES = [
+    ".env.template",
+    "nginx.conf.template",
+    "docker-compose.yml",
+    ".template-version",
+    "authentik/octopize-avatar-blueprint.yaml.j2",
+]
+
+
+class TemplateProvider(ABC):
+    """Abstract base class for template providers."""
+
+    def __init__(self, verbose: bool = False):
+        """
+        Initialize template provider.
+
+        Args:
+            verbose: Print progress information
+        """
+        self.verbose = verbose
+
+    @abstractmethod
+    def provide_file(self, filename: str, destination: Path) -> bool:
+        """
+        Provide a single file to the destination.
+
+        Args:
+            filename: Name of file to provide
+            destination: Local path where file should be saved
+
+        Returns:
+            True if successful, False otherwise
+        """
+        pass
+
+    def provide_all(self, output_dir: Path) -> bool:
+        """
+        Provide all required template files.
+
+        Args:
+            output_dir: Directory where files should be saved
+
+        Returns:
+            True if all files provided successfully
+        """
+        output_dir = Path(output_dir)
+        success = True
+
+        if self.verbose:
+            print(f"\nProviding templates to {output_dir}/")
+            print("=" * 60)
+
+        for filename in REQUIRED_FILES:
+            destination = output_dir / filename
+            if not self.provide_file(filename, destination):
+                success = False
+                print(f"⚠ Warning: Failed to provide {filename}")
+
+        if self.verbose:
+            if success:
+                print("\n✓ All templates provided successfully")
+            else:
+                print("\n⚠ Some templates failed")
+
+        return success
+
+    def check_cached_templates(self, output_dir: Path) -> bool:
+        """
+        Check if templates are already cached locally.
+
+        Args:
+            output_dir: Directory to check for cached templates
+
+        Returns:
+            True if all required files exist
+        """
+        output_dir = Path(output_dir)
+        for filename in REQUIRED_FILES:
+            if not (output_dir / filename).exists():
+                return False
+        return True
+
+
+class GitHubTemplateProvider(TemplateProvider):
+    """Downloads deployment templates from GitHub."""
+
+    def __init__(self, branch: str = DEFAULT_BRANCH, verbose: bool = False):
+        """
+        Initialize GitHub template provider.
+
+        Args:
+            branch: Git branch to download from (default: main)
+            verbose: Print download progress
+        """
+        super().__init__(verbose=verbose)
+        self.branch = branch
+        self.base_url = f"{GITHUB_RAW_BASE}/{branch}/docker/templates"
+
+    def provide_file(self, filename: str, destination: Path) -> bool:
+        """
+        Download a single file from GitHub.
+
+        Args:
+            filename: Name of file to download (in docker/templates/ directory)
+            destination: Local path where file should be saved
+
+        Returns:
+            True if successful, False otherwise
+        """
+        url = f"{self.base_url}/{filename}"
+
+        if self.verbose:
+            print(f"Downloading {filename}...")
+            print(f"  URL: {url}")
+            print(f"  Destination: {destination}")
+
+        try:
+            with urllib.request.urlopen(url, timeout=10) as response:
+                content = response.read()
+
+            # Ensure parent directory exists
+            destination.parent.mkdir(parents=True, exist_ok=True)
+
+            # Write file
+            destination.write_bytes(content)
+
+            if self.verbose:
+                print(f"  ✓ Downloaded {len(content)} bytes")
+
+            return True
+
+        except Exception as e:
+            if self.verbose:
+                print(f"  ✗ Failed: {e}")
+            return False
+
+    def check_cached_templates(self, output_dir: Path) -> bool:
+        """
+        Check if templates are already cached locally.
+
+        Args:
+            output_dir: Directory to check for cached templates
+
+        Returns:
+            True if all required files exist
+        """
+        output_dir = Path(output_dir)
+        for filename in REQUIRED_FILES:
+            if not (output_dir / filename).exists():
+                return False
+        return True
+
+
+class LocalTemplateProvider(TemplateProvider):
+    """Provides templates from a local directory (for testing)."""
+
+    def __init__(self, source_dir: Path | str, verbose: bool = False):
+        """
+        Initialize local template provider.
+
+        Args:
+            source_dir: Local directory containing template files
+            verbose: Print progress information
+        """
+        super().__init__(verbose=verbose)
+        self.source_dir = Path(source_dir)
+
+    def provide_file(self, filename: str, destination: Path) -> bool:
+        """
+        Copy a single file from source to destination.
+
+        Args:
+            filename: Name of file to copy
+            destination: Local path where file should be saved
+
+        Returns:
+            True if successful, False otherwise
+        """
+        source = self.source_dir / filename
+
+        if self.verbose:
+            print(f"Copying {filename}...")
+            print(f"  Source: {source}")
+            print(f"  Destination: {destination}")
+
+        try:
+            if not source.exists():
+                raise FileNotFoundError(f"Source file not found: {source}")
+
+            # Ensure parent directory exists
+            destination.parent.mkdir(parents=True, exist_ok=True)
+
+            # Copy file
+            shutil.copy2(source, destination)
+
+            if self.verbose:
+                print(f"  ✓ Copied {source.stat().st_size} bytes")
+
+            return True
+
+        except Exception as e:
+            if self.verbose:
+                print(f"  ✗ Failed: {e}")
+            return False
+
+
+def download_templates(
+    output_dir: Path,
+    force: bool = False,
+    branch: str = DEFAULT_BRANCH,
+    verbose: bool = False,
+) -> bool:
+    """
+    Download deployment templates from GitHub.
+
+    Args:
+        output_dir: Directory where templates should be saved
+        force: Force download even if files already exist
+        branch: Git branch to download from
+        verbose: Print progress information
+
+    Returns:
+        True if successful
+    """
+    provider = GitHubTemplateProvider(branch=branch, verbose=verbose)
+
+    # Check if already cached
+    if not force and provider.check_cached_templates(output_dir):
+        if verbose:
+            print(f"Templates already cached in {output_dir}/")
+        return True
+
+    # Download
+    return provider.provide_all(output_dir)

octopize_avatar_deploy/input_gatherer.py

@@ -0,0 +1,324 @@
+"""
+Input gathering abstraction for deployment tool.
+
+Provides pluggable input gathering through Protocol pattern, enabling:
+- Standard console input for production
+- Mock input for testing
+- Rich library input with enhanced features
+"""
+
+import os
+import sys
+from collections.abc import Callable
+from typing import Protocol, runtime_checkable
+
+from rich.console import Console
+from rich.prompt import Confirm, IntPrompt, Prompt
+
+
+@runtime_checkable
+class InputGatherer(Protocol):
+    """
+    Protocol defining input gathering interface.
+
+    This allows different implementations (console, mock, rich) while
+    maintaining type safety through Protocol pattern.
+    """
+
+    def prompt(
+        self,
+        message: str,
+        default: str | None = None,
+        validate: Callable[[str], tuple[bool, str]] | None = None,
+    ) -> str:
+        """
+        Prompt user for input with optional default value and validation.
+
+        Args:
+            message: The prompt message
+            default: Default value to use if user presses Enter (None = required field)
+            validate: Optional validation function that returns (is_valid, error_message)
+
+        Returns:
+            User's input or default value
+        """
+        ...
+
+    def prompt_yes_no(self, message: str, default: bool = True) -> bool:
+        """
+        Prompt user for yes/no input.
+
+        Args:
+            message: The prompt message
+            default: Default value if user presses Enter
+
+        Returns:
+            True for yes, False for no
+        """
+        ...
+
+    def prompt_choice(self, message: str, choices: list[str], default: str | None = None) -> str:
+        """
+        Prompt user to choose from list of options.
+
+        Args:
+            message: The prompt message
+            choices: List of valid choices
+            default: Default choice if user presses Enter
+
+        Returns:
+            Selected choice
+        """
+        ...
+
+
+class ConsoleInputGatherer:
+    """
+    Standard console-based input gatherer using built-in input().
+
+    This is the default implementation for production use.
+    """
+
+    def prompt(
+        self,
+        message: str,
+        default: str | None = None,
+        validate: Callable[[str], tuple[bool, str]] | None = None,
+    ) -> str:
+        """Prompt user for input with optional default value and validation."""
+        # Debug logging
+        if os.environ.get("AVATAR_DEPLOY_DEBUG_PROMPTS") == "1":
+            debug_msg = f"[PROMPT] {message}"
+            if default is not None:
+                debug_msg += f" (default: {default!r})"
+            print(debug_msg, file=sys.stderr)
+
+        while True:
+            if default is not None:  # Has a default (including empty string)
+                prompt_text = (
+                    f"{message} [{default}]: " if default else f"{message} [press Enter to skip]: "
+                )
+                response = input(prompt_text).strip()
+                value = response if response else default
+            else:  # No default - required field
+                response = input(f"{message}: ").strip()
+                if not response:
+                    print("  ⚠ This value is required")
+                    continue
+                value = response
+
+            # Validate if validator provided
+            if validate:
+                is_valid, error_msg = validate(value)
+                if not is_valid:
+                    print(f"  ⚠ {error_msg}")
+                    continue
+
+            return value
+
+    def prompt_yes_no(self, message: str, default: bool = True) -> bool:
+        """Prompt user for yes/no input."""
+        default_str = "Y/n" if default else "y/N"
+        response = input(f"{message} [{default_str}]: ").strip().lower()
+
+        if not response:
+            return default
+
+        return response in ["y", "yes", "true", "1"]
+
+    def prompt_choice(self, message: str, choices: list[str], default: str | None = None) -> str:
+        """Prompt user to choose from list of options."""
+        print(f"\n{message}")
+        for i, choice in enumerate(choices, 1):
+            marker = " (default)" if choice == default else ""
+            print(f"  {i}. {choice}{marker}")
+
+        while True:
+            response = input(f"\nSelect [1-{len(choices)}]: ").strip()
+
+            if not response and default:
+                return default
+
+            try:
+                choice_num = int(response)
+                if 1 <= choice_num <= len(choices):
+                    return choices[choice_num - 1]
+                else:
+                    print(f"  ⚠ Please enter a number between 1 and {len(choices)}")
+            except ValueError:
+                print("  ⚠ Please enter a valid number")
+
+
+class MockInputGatherer:
+    """
+    Mock input gatherer for testing.
+
+    Returns pre-configured responses in sequence. Useful for testing
+    interactive flows without manual input.
+    """
+
+    def __init__(self, responses: list[str | bool]):
+        """
+        Initialize mock input gatherer.
+
+        Args:
+            responses: List of pre-configured responses to return in sequence
+        """
+        self.responses = responses
+        self.current_index = 0
+
+    def _get_next_response(self) -> str | bool:
+        """Get next response from the queue."""
+        if self.current_index >= len(self.responses):
+            raise ValueError(
+                f"MockInputGatherer ran out of responses (asked {self.current_index + 1} times)"
+            )
+        response = self.responses[self.current_index]
+        self.current_index += 1
+        return response
+
+    def prompt(
+        self,
+        message: str,
+        default: str | None = None,
+        validate: Callable[[str], tuple[bool, str]] | None = None,
+    ) -> str:
+        """Return next mocked response."""
+        # Debug logging with response preview
+        if os.environ.get("AVATAR_DEPLOY_DEBUG_PROMPTS") == "1":
+            response_preview = (
+                self.responses[self.current_index]
+                if self.current_index < len(self.responses)
+                else f"<default: {default!r}>"
+            )
+            print(
+                f"[PROMPT #{self.current_index + 1}] {message} => {response_preview!r}",
+                file=sys.stderr,
+            )
+
+        response = self._get_next_response()
+
+        if isinstance(response, bool):
+            raise TypeError(
+                "Expected string response, got bool: True"
+                if response
+                else "Expected string response, got bool: False"
+            )
+
+        # Use default if response is empty string and default is provided
+        value = response if response else (default if default is not None else response)
+
+        # Validate if validator provided (for testing validation logic)
+        if validate:
+            is_valid, error_msg = validate(value)
+            if not is_valid:
+                raise ValueError(f"MockInputGatherer: Validation failed for '{value}': {error_msg}")
+
+        return value
+
+    def prompt_yes_no(self, message: str, default: bool = True) -> bool:
+        """Return next mocked boolean response."""
+        response = self._get_next_response()
+        if isinstance(response, str):
+            # Convert string to boolean if needed
+            return response.lower() in ["y", "yes", "true", "1"]
+        return response
+
+    def prompt_choice(self, message: str, choices: list[str], default: str | None = None) -> str:
+        """Return next mocked choice response."""
+        response = self._get_next_response()
+        if isinstance(response, bool):
+            raise TypeError(f"Expected string response, got bool: {response}")
+
+        # If response is empty and default is provided, return default
+        if not response and default:
+            return default
+
+        # If response is a number, treat it as choice index (1-based)
+        try:
+            choice_num = int(response)
+            if 1 <= choice_num <= len(choices):
+                return choices[choice_num - 1]
+        except (ValueError, TypeError):
+            pass
+
+        # Otherwise, return the response as-is (assuming it's a valid choice)
+        return response
+
+
+class RichInputGatherer:
+    """
+    Rich-based input gatherer with enhanced prompts.
+
+    Uses the 'rich' library to provide beautiful interactive prompts with:
+    - Styled prompts with colors
+    - Better formatting
+    - Input validation
+    """
+
+    def __init__(self):
+        """Initialize RichInputGatherer with a Console instance."""
+        self.console = Console()
+
+    def prompt(
+        self,
+        message: str,
+        default: str | None = None,
+        validate: Callable[[str], tuple[bool, str]] | None = None,
+    ) -> str:
+        """Prompt user for input with optional default value and validation."""
+        while True:
+            if default is not None:  # Has a default (including empty string)
+                if default:
+                    result = Prompt.ask(f"[cyan]{message}[/cyan]", default=default)
+                else:
+                    # Empty string default - show skip hint
+                    result = Prompt.ask(f"[cyan]{message} (press Enter to skip)[/cyan]", default="")
+            else:  # No default - required field
+                # Rich Prompt requires at least empty string, so we loop
+                result = ""
+                while not result:
+                    result = Prompt.ask(f"[cyan]{message}[/cyan]").strip()
+                    if not result:
+                        self.console.print("[yellow]⚠ This value is required[/yellow]")
+
+            # Validate if validator provided
+            if validate:
+                is_valid, error_msg = validate(result)
+                if not is_valid:
+                    self.console.print(f"[yellow]⚠ {error_msg}[/yellow]")
+                    continue
+
+            return result
+
+    def prompt_yes_no(self, message: str, default: bool = True) -> bool:
+        """Prompt user for yes/no input."""
+        return Confirm.ask(f"[cyan]{message}[/cyan]", default=default)
+
+    def prompt_choice(self, message: str, choices: list[str], default: str | None = None) -> str:
+        """Prompt user to choose from list of options."""
+        self.console.print(f"\n[cyan]{message}[/cyan]")
+        for i, choice in enumerate(choices, 1):
+            marker = " [dim](default)[/dim]" if choice == default else ""
+            self.console.print(f"  [bold]{i}[/bold]. {choice}{marker}")
+
+        # Determine default index
+        default_index = None
+        if default and default in choices:
+            default_index = choices.index(default) + 1
+
+        while True:
+            if default_index:
+                choice_num = IntPrompt.ask(
+                    f"\n[cyan]Select[/cyan] [dim]\\[1-{len(choices)}][/dim]",
+                    default=default_index,
+                )
+            else:
+                choice_num = IntPrompt.ask(f"\n[cyan]Select[/cyan] [dim]\\[1-{len(choices)}][/dim]")
+
+            if 1 <= choice_num <= len(choices):
+                return choices[choice_num - 1]
+            else:
+                self.console.print(
+                    f"[yellow]⚠ Please enter a number between 1 and {len(choices)}[/yellow]"
+                )