solokit 0.1.1__py3-none-any.whl

solokit/quality/env_validator.py

@@ -0,0 +1,306 @@
+#!/usr/bin/env python3
+"""
+Environment validation for deployments.
+
+Validates:
+- Environment readiness (connectivity, resources)
+- Configuration (environment variables, secrets)
+- Dependencies (services, databases, APIs)
+- Service health (endpoints, databases)
+- Monitoring systems
+- Infrastructure (load balancers, DNS)
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from typing import Any
+
+from solokit.core.error_handlers import log_errors
+from solokit.core.exceptions import ErrorCode, ValidationError
+from solokit.core.output import get_output
+
+output = get_output()
+logger = logging.getLogger(__name__)
+
+
+class EnvironmentValidator:
+    """Environment validation for deployments."""
+
+    def __init__(self, environment: str):
+        """Initialize environment validator."""
+        self.environment = environment
+        self.validation_results: list[Any] = []
+
+    def validate_connectivity(self) -> tuple[bool, dict[str, Any]]:
+        """
+        Validate network connectivity to target environment.
+
+        Returns:
+            (passed, results)
+        """
+        results: dict[str, Any] = {"checks": [], "passed": True}
+
+        # NOTE: Framework stub - Implement project-specific connectivity checks
+        # Suggested checks for production use:
+        # - API endpoints (HTTP/HTTPS connectivity)
+        # - Database endpoints (TCP connectivity, auth)
+        # - Cache endpoints (Redis, Memcached, etc.)
+        # Returns True by default to allow framework operation
+
+        return results["passed"], results
+
+    @log_errors()
+    def validate_configuration(self, required_vars: list[str]) -> dict[str, Any]:
+        """
+        Validate required environment variables and secrets.
+
+        Args:
+            required_vars: List of required environment variable names
+
+        Returns:
+            Dict with validation results
+
+        Raises:
+            ValidationError: If any required environment variable is missing or empty
+        """
+        results: dict[str, Any] = {"checks": [], "passed": True}
+        missing_vars = []
+
+        for var in required_vars:
+            value = os.environ.get(var)
+            check_passed = value is not None and value != ""
+
+            results["checks"].append(
+                {"name": f"Environment variable: {var}", "passed": check_passed}
+            )
+
+            if not check_passed:
+                results["passed"] = False
+                missing_vars.append(var)
+
+        if missing_vars:
+            raise ValidationError(
+                message=f"Missing or empty required environment variables: {', '.join(missing_vars)}",
+                code=ErrorCode.MISSING_REQUIRED_FIELD,
+                context={
+                    "missing_variables": missing_vars,
+                    "environment": self.environment,
+                },
+                remediation=f"Set the following environment variables: {', '.join(missing_vars)}",
+            )
+
+        return results
+
+    def validate_dependencies(self) -> tuple[bool, dict[str, Any]]:
+        """
+        Validate service dependencies are available.
+
+        Returns:
+            (passed, results)
+        """
+        results: dict[str, Any] = {"checks": [], "passed": True}
+
+        # NOTE: Framework stub - Implement project-specific dependency checks
+        # Suggested checks for production use:
+        # - Database accessible (connection test)
+        # - Cache accessible (ping test)
+        # - External APIs accessible (health check endpoints)
+        # - Message queues accessible (broker connectivity)
+        # Returns True by default to allow framework operation
+
+        return results["passed"], results
+
+    def validate_health_checks(self) -> tuple[bool, dict[str, Any]]:
+        """
+        Validate health check endpoints.
+
+        Returns:
+            (passed, results)
+        """
+        results: dict[str, Any] = {"checks": [], "passed": True}
+
+        # NOTE: Framework stub - Implement project-specific health checks
+        # Suggested checks for production use:
+        # - Application health endpoint (HTTP GET /health)
+        # - Database health (query execution test)
+        # - Cache health (read/write test)
+        # Returns True by default to allow framework operation
+
+        return results["passed"], results
+
+    def validate_monitoring(self) -> tuple[bool, dict[str, Any]]:
+        """
+        Validate monitoring system operational.
+
+        Returns:
+            (passed, results)
+        """
+        results: dict[str, Any] = {"checks": [], "passed": True}
+
+        # NOTE: Framework stub - Implement project-specific monitoring checks
+        # Suggested checks for production use:
+        # - Monitoring agent running (process check)
+        # - Dashboards accessible (Grafana, Datadog, etc.)
+        # - Alerting configured (PagerDuty, Slack webhooks)
+        # Returns True by default to allow framework operation
+
+        return results["passed"], results
+
+    def validate_infrastructure(self) -> tuple[bool, dict[str, Any]]:
+        """
+        Validate infrastructure components.
+
+        Returns:
+            (passed, results)
+        """
+        results: dict[str, Any] = {"checks": [], "passed": True}
+
+        # NOTE: Framework stub - Implement project-specific infrastructure checks
+        # Suggested checks for production use:
+        # - Load balancer configured (health check, routing rules)
+        # - DNS records correct (A, CNAME, TXT records)
+        # - SSL certificates valid (expiration, chain verification)
+        # - CDN configured (CloudFront, Cloudflare, etc.)
+        # Returns True by default to allow framework operation
+
+        return results["passed"], results
+
+    def validate_capacity(self) -> tuple[bool, dict[str, Any]]:
+        """
+        Validate sufficient capacity for deployment.
+
+        Returns:
+            (passed, results)
+        """
+        results: dict[str, Any] = {"checks": [], "passed": True}
+
+        # NOTE: Framework stub - Implement project-specific capacity checks
+        # Suggested checks for production use:
+        # - Disk space available (>20% free recommended)
+        # - Memory available (check available vs. total)
+        # - CPU capacity (check load average)
+        # - Database connections available (check pool usage)
+        # Returns True by default to allow framework operation
+
+        return results["passed"], results
+
+    def validate_all(
+        self, required_env_vars: list[str] | None = None
+    ) -> tuple[bool, dict[str, Any]]:
+        """
+        Run all validation checks.
+
+        Args:
+            required_env_vars: List of required environment variables
+
+        Returns:
+            (passed, results)
+        """
+        all_results: dict[str, Any] = {"validations": [], "passed": True}
+
+        # Connectivity
+        passed, results = self.validate_connectivity()
+        all_results["validations"].append(
+            {"name": "Connectivity", "passed": passed, "details": results}
+        )
+        if not passed:
+            all_results["passed"] = False
+
+        # Configuration
+        if required_env_vars:
+            try:
+                results = self.validate_configuration(required_env_vars)
+                all_results["validations"].append(
+                    {"name": "Configuration", "passed": True, "details": results}
+                )
+            except ValidationError as e:
+                all_results["validations"].append(
+                    {
+                        "name": "Configuration",
+                        "passed": False,
+                        "details": {"error": e.message, "context": e.context},
+                    }
+                )
+                all_results["passed"] = False
+
+        # Dependencies
+        passed, results = self.validate_dependencies()
+        all_results["validations"].append(
+            {"name": "Dependencies", "passed": passed, "details": results}
+        )
+        if not passed:
+            all_results["passed"] = False
+
+        # Health checks
+        passed, results = self.validate_health_checks()
+        all_results["validations"].append(
+            {"name": "Health Checks", "passed": passed, "details": results}
+        )
+        if not passed:
+            all_results["passed"] = False
+
+        # Monitoring
+        passed, results = self.validate_monitoring()
+        all_results["validations"].append(
+            {"name": "Monitoring", "passed": passed, "details": results}
+        )
+        if not passed:
+            all_results["passed"] = False
+
+        # Infrastructure
+        passed, results = self.validate_infrastructure()
+        all_results["validations"].append(
+            {"name": "Infrastructure", "passed": passed, "details": results}
+        )
+        if not passed:
+            all_results["passed"] = False
+
+        # Capacity
+        passed, results = self.validate_capacity()
+        all_results["validations"].append(
+            {"name": "Capacity", "passed": passed, "details": results}
+        )
+        if not passed:
+            all_results["passed"] = False
+
+        return all_results["passed"], all_results
+
+
+def main() -> None:
+    """CLI entry point.
+
+    Raises:
+        SystemExit: Always exits with code 0 on success, 1 on failure
+    """
+    import sys
+
+    if len(sys.argv) < 2:
+        logger.error("Missing required argument: environment")
+        output.error("Usage: environment_validator.py <environment>")
+        sys.exit(1)
+
+    environment = sys.argv[1]
+    validator = EnvironmentValidator(environment)
+
+    try:
+        passed, results = validator.validate_all()
+
+        output.info(f"\nEnvironment Validation: {'✓ PASSED' if passed else '✗ FAILED'}")
+        for validation in results["validations"]:
+            status = "✓" if validation["passed"] else "✗"
+            output.info(f"  {status} {validation['name']}")
+
+        sys.exit(0 if passed else 1)
+    except ValidationError as e:
+        logger.error(f"Validation failed: {e.message}", extra=e.to_dict())
+        output.error("\nEnvironment Validation: ✗ FAILED")
+        output.error(f"Error: {e.message}")
+        if e.remediation:
+            output.error(f"Remediation: {e.remediation}")
+        sys.exit(e.exit_code)
+
+
+if __name__ == "__main__":
+    main()