prole/installer/milestone.py

"""Milestone abstraction for the UI-agnostic installer core."""
from __future__ import annotations

from abc import ABC, abstractmethod
from typing import Callable, Sequence

from . import config as inst_config
from .state import InstallerState

ProgressCallback = Callable[[str, float | None], None]
ValidationResult = str | Sequence[str] | None


class Milestone(ABC):
    """Base class for installer milestones.

    Milestones encapsulate business logic, validation, and flow control.
    They must not import or depend on UI toolkits.
    """

    id: str
    title: str

    def __init__(self, milestone_id: str, title: str):
        self.id = milestone_id
        self.title = title

    def validate(self, state: InstallerState) -> ValidationResult:
        """Return a validation error or None when valid."""
        return None

    @abstractmethod
    def execute(self, state: InstallerState, progress: ProgressCallback | None = None) -> None:
        """Execute milestone logic. Use the progress callback to emit updates."""
        raise NotImplementedError

    def next(self, state: InstallerState) -> str | None:
        """Return the next milestone id or None to finish."""
        return None

    def _parse_bool(self, val: any, default: bool | None = False) -> bool | None:
        return inst_config._parse_bool(val, default)

    def _run_cmd(self, cmd: str | list[str], cwd: str | None = None, on_stdout: callable | None = None) -> int:
        if isinstance(cmd, str):
            cmd = ['bash', '-c', cmd]
        
        import subprocess
        try:
            proc = subprocess.Popen(
                cmd,
                stdout=subprocess.PIPE,
                stderr=subprocess.STDOUT,
                text=True,
                bufsize=1,
                cwd=cwd
            )
            for line in iter(proc.stdout.readline, ''):
                if on_stdout:
                    on_stdout(line)
            return proc.wait()
        except Exception:
            return 1

    def _get_script_env(self, state: InstallerState) -> dict:
        import os
        from pathlib import Path
        env = os.environ.copy()
        project_root = inst_config.PROJECT_ROOT
        env["PROLE_HOME"] = str(project_root)
        env["PROLE_SERVICE"] = str(project_root)
        
        namespace = state.inputs.get('init_password.db_namespace', 'default')
        env["NAMESPACE"] = namespace
        
        # Paths
        env["PROLE_CONF"] = state.inputs.get('env_setup.PROLE_CONF', str(project_root / "conf"))
        env["PROLE_DATA"] = state.inputs.get('env_setup.PROLE_DATA', str(project_root / "prole-db" / "data"))
        env["PROLE_LOGS"] = state.inputs.get('env_setup.PROLE_LOGS', str(project_root / "logs"))
        env["PROLE_SERVICE"] = state.inputs.get('env_setup.PROLE_SERVICE', str(project_root / "etc"))

        service_ns = (state.config_data.get('Global', {}) or {}).get('SERVICE_NAMESPACE', '').strip()
        if not service_ns:
            service_ns = (os.environ.get('SERVICE_NAMESPACE') or '').strip()
        if not service_ns:
            service_ns = namespace or 'default'
        env["SERVICE_NAMESPACE"] = service_ns

        from installer.core.env import _deployment_mode_from_env
        cluster_env = state.inputs.get('init_cluster.cluster_env', 'dev')
        mode = _deployment_mode_from_env(cluster_env) or 'k3d'
        env["PROLE_MODE"] = mode

        # Kubeconfig (k3s only)
        if mode == "k3s":
            kc = Path(env["PROLE_SERVICE"]) / "secrets" / "k3s.kubeconfig"
            if not kc.exists():
                kc = project_root / "etc" / "secrets" / "k3s.kubeconfig"
            if kc.exists():
                env["KUBECONFIG"] = str(kc)
        
        db_pw = state.inputs.get('init_password.db_password', '').strip()
        if db_pw:
            db_pw = inst_config._resolve_secret_value(db_pw)
            env["DB_PASSWORD"] = db_pw
            env["OPENTOFU_ADMIN_PASSWORD"] = db_pw

        grafana_pw = (state.config_data.get('Monitoring', {}) or {}).get('GRAFANA_ADMIN_PASSWORD', '').strip()
        resolved_grafana = inst_config._resolve_secret_value(grafana_pw) if grafana_pw else ""
        if resolved_grafana and not inst_config._is_openbao_ref(resolved_grafana) and not inst_config._is_prole_secret(resolved_grafana):
            env["GRAFANA_ADMIN_PASSWORD"] = resolved_grafana
        elif db_pw:
            env["GRAFANA_ADMIN_PASSWORD"] = db_pw

        db_user = (state.inputs.get('init_password.db_username', '') or '').strip()
        if db_user:
            env["PROLE_DB_USER"] = db_user
            
        # Kerberos
        env["KRB5_REALM"] = state.inputs.get('kerberos_config.realm', '')
        realm = (state.inputs.get('kerberos_config.realm', '') or '').strip()
        env["KRB5_KDC"] = state.inputs.get('kerberos_config.kdc', '')
        if realm:
            env["REALM"] = realm
            env["DOMAIN"] = realm.lower()
        env["KRB5_USER"] = state.inputs.get('kerberos_config.user', '')
        krb_pw = state.inputs.get('kerberos_config.password', '')
        if krb_pw:
            env["KRB5_PASSWORD"] = inst_config._resolve_secret_value(krb_pw)
        if state.inputs.get('kerberos_config.kdc', ''):
            env["KRB5_ADMIN"] = state.inputs.get('kerberos_config.kdc', '')

        kerberos_enabled = self._parse_bool(state.inputs.get('kerberos_config.enabled', 'False'), default=False)
        if kerberos_enabled is None:
            kerberos_enabled = False
        env["KERBEROS_ENABLED"] = "True" if kerberos_enabled else "False"
        env["ENABLED"] = env["KERBEROS_ENABLED"]

        at_rest = state.inputs.get('init_cluster.at_rest_encryption_enabled', '')
        if at_rest != '':
            env["AT_REST_ENCRYPTION_ENABLED"] = str(at_rest)

        argocd_ns = (state.config_data.get('Global', {}) or {}).get('ARGOCD_NAMESPACE', '').strip()
        if not argocd_ns:
            argocd_ns = (os.environ.get('ARGOCD_NAMESPACE') or '').strip() or 'argocd'
        env["ARGOCD_NAMESPACE"] = argocd_ns
        registry_ns = (state.config_data.get('Global', {}) or {}).get('REGISTRY_NAMESPACE', '').strip()
        if not registry_ns:
            registry_ns = (os.environ.get('REGISTRY_NAMESPACE') or '').strip() or 'default'
        env["REGISTRY_NAMESPACE"] = registry_ns
        
        if mode == 'k3s':
            server = state.inputs.get('init_cluster.k3s_server_url', '').strip()
            token = state.inputs.get('init_cluster.k3s_token', '').strip()
            if token:
                token = inst_config._resolve_secret_value(token)
            if server:
                if not server.startswith('http'):
                    server = f"https://{server}"
                env["PROLE_K3S_SERVER"] = server
            if token:
                env["PROLE_K3S_TOKEN"] = token
                
        return env