vm-tool 1.0.32__py3-none-any.whl

vm_tool/strategies/canary.py

@@ -0,0 +1,277 @@
+"""Canary deployment strategy with gradual rollout and automatic rollback."""
+
+import logging
+import time
+from typing import Optional, Dict, Any, List
+from dataclasses import dataclass
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class CanaryConfig:
+    """Configuration for canary deployment."""
+
+    initial_percentage: int = 10  # Start with 10% traffic
+    increment_percentage: int = 10  # Increase by 10% each step
+    increment_interval: int = 300  # Wait 5 minutes between increments
+    success_threshold: float = 99.0  # 99% success rate required
+    error_threshold: float = 1.0  # Max 1% error rate
+    rollback_on_failure: bool = True
+
+
+class CanaryDeployment:
+    """Manage canary deployments with gradual traffic shifting."""
+
+    def __init__(
+        self,
+        production_host: str,
+        canary_host: str,
+        config: Optional[CanaryConfig] = None,
+    ):
+        self.production_host = production_host
+        self.canary_host = canary_host
+        self.config = config or CanaryConfig()
+        self.current_percentage = 0
+
+    def deploy(
+        self,
+        compose_file: str,
+        monitor_metrics: bool = True,
+    ) -> Dict[str, Any]:
+        """Execute canary deployment with gradual rollout.
+
+        Args:
+            compose_file: Docker compose file to deploy
+            monitor_metrics: Whether to monitor metrics during rollout
+
+        Returns:
+            Deployment result
+        """
+        logger.info("🐤 Starting canary deployment")
+        logger.info(f"   Production: {self.production_host}")
+        logger.info(f"   Canary: {self.canary_host}")
+        logger.info(f"   Initial traffic: {self.config.initial_percentage}%")
+
+        result = {
+            "success": False,
+            "canary_host": self.canary_host,
+            "final_percentage": 0,
+            "steps": [],
+        }
+
+        try:
+            # Step 1: Deploy to canary environment
+            logger.info("📦 Deploying to canary environment...")
+            self._deploy_to_canary(compose_file)
+
+            # Step 2: Health check canary
+            logger.info("🏥 Running health checks on canary...")
+            if not self._health_check(self.canary_host):
+                raise Exception("Canary health check failed")
+
+            # Step 3: Gradual traffic shift
+            logger.info("🔄 Starting gradual traffic shift...")
+            self.current_percentage = self.config.initial_percentage
+
+            while self.current_percentage < 100:
+                logger.info(
+                    f"   Shifting {self.current_percentage}% traffic to canary..."
+                )
+                self._shift_traffic(self.current_percentage)
+
+                result["steps"].append(
+                    {
+                        "percentage": self.current_percentage,
+                        "timestamp": time.time(),
+                    }
+                )
+
+                # Monitor metrics if enabled
+                if monitor_metrics and self.current_percentage < 100:
+                    logger.info(
+                        f"   Monitoring metrics for {self.config.increment_interval}s..."
+                    )
+                    time.sleep(self.config.increment_interval)
+
+                    metrics = self._get_canary_metrics()
+                    logger.info(f"   Canary metrics: {metrics}")
+
+                    # Check if metrics are acceptable
+                    if not self._metrics_acceptable(metrics):
+                        logger.error("❌ Canary metrics failed threshold")
+                        if self.config.rollback_on_failure:
+                            self._rollback()
+                        raise Exception("Canary metrics below threshold")
+
+                # Increment traffic percentage
+                if self.current_percentage < 100:
+                    self.current_percentage = min(
+                        100, self.current_percentage + self.config.increment_percentage
+                    )
+
+            # Step 4: Full cutover
+            logger.info("✅ Canary deployment successful - full cutover complete")
+            result["success"] = True
+            result["final_percentage"] = 100
+
+            return result
+
+        except Exception as e:
+            logger.error(f"❌ Canary deployment failed: {e}")
+            result["error"] = str(e)
+            return result
+
+    def _deploy_to_canary(self, compose_file: str):
+        """Deploy to canary environment."""
+        logger.info(f"   Deploying {compose_file} to {self.canary_host}")
+        # TODO: Integrate with deploy-docker
+        pass
+
+    def _health_check(self, host: str) -> bool:
+        """Check if host is healthy."""
+        from vm_tool.health import check_http
+
+        try:
+            return check_http(f"http://{host}/health")
+        except:
+            return False
+
+    def _shift_traffic(self, percentage: int):
+        """Shift traffic to canary.
+
+        Args:
+            percentage: Percentage of traffic to send to canary (0-100)
+        """
+        # This would update load balancer configuration
+        # Implementation depends on LB type (nginx, AWS ALB, etc.)
+        logger.info(f"   Traffic shift: {percentage}% to canary")
+        # TODO: Implement actual traffic shifting
+        pass
+
+    def _get_canary_metrics(self) -> Dict[str, float]:
+        """Get metrics from canary environment."""
+        # This would fetch actual metrics from monitoring system
+        # For now, return dummy metrics
+        return {
+            "success_rate": 99.5,
+            "error_rate": 0.5,
+            "avg_response_time": 120,
+            "requests_per_second": 100,
+        }
+
+    def _metrics_acceptable(self, metrics: Dict[str, float]) -> bool:
+        """Check if metrics meet thresholds."""
+        success_rate = metrics.get("success_rate", 0)
+        error_rate = metrics.get("error_rate", 100)
+
+        if success_rate < self.config.success_threshold:
+            logger.warning(
+                f"   Success rate {success_rate}% below threshold {self.config.success_threshold}%"
+            )
+            return False
+
+        if error_rate > self.config.error_threshold:
+            logger.warning(
+                f"   Error rate {error_rate}% above threshold {self.config.error_threshold}%"
+            )
+            return False
+
+        return True
+
+    def _rollback(self):
+        """Rollback canary deployment."""
+        logger.info("🔄 Rolling back canary deployment...")
+        self._shift_traffic(0)  # Send all traffic back to production
+        logger.info("✅ Rollback complete")
+
+
+class ProgressiveRollout:
+    """Progressive rollout across multiple hosts."""
+
+    def __init__(self, hosts: List[str], batch_size: int = 1):
+        self.hosts = hosts
+        self.batch_size = batch_size
+        self.deployed_hosts: List[str] = []
+
+    def deploy(
+        self,
+        compose_file: str,
+        wait_between_batches: int = 60,
+    ) -> Dict[str, Any]:
+        """Deploy progressively across hosts.
+
+        Args:
+            compose_file: Docker compose file
+            wait_between_batches: Seconds to wait between batches
+
+        Returns:
+            Deployment result
+        """
+        logger.info(f"🚀 Starting progressive rollout to {len(self.hosts)} hosts")
+        logger.info(f"   Batch size: {self.batch_size}")
+
+        result = {
+            "success": False,
+            "deployed_hosts": [],
+            "failed_hosts": [],
+        }
+
+        # Deploy in batches
+        for i in range(0, len(self.hosts), self.batch_size):
+            batch = self.hosts[i : i + self.batch_size]
+            batch_num = (i // self.batch_size) + 1
+            total_batches = (len(self.hosts) + self.batch_size - 1) // self.batch_size
+
+            logger.info(f"📦 Deploying batch {batch_num}/{total_batches}: {batch}")
+
+            for host in batch:
+                try:
+                    self._deploy_to_host(host, compose_file)
+
+                    # Health check
+                    if self._health_check(host):
+                        self.deployed_hosts.append(host)
+                        result["deployed_hosts"].append(host)
+                        logger.info(f"   ✅ {host} deployed successfully")
+                    else:
+                        raise Exception("Health check failed")
+
+                except Exception as e:
+                    logger.error(f"   ❌ {host} deployment failed: {e}")
+                    result["failed_hosts"].append(host)
+                    # Optionally stop on first failure
+                    # raise
+
+            # Wait before next batch (unless this is the last batch)
+            if i + self.batch_size < len(self.hosts):
+                logger.info(f"⏳ Waiting {wait_between_batches}s before next batch...")
+                time.sleep(wait_between_batches)
+
+        result["success"] = len(result["failed_hosts"]) == 0
+
+        if result["success"]:
+            logger.info(
+                f"✅ Progressive rollout complete: {len(self.deployed_hosts)} hosts"
+            )
+        else:
+            logger.warning(
+                f"⚠️  Rollout completed with failures: {len(result['failed_hosts'])} failed"
+            )
+
+        return result
+
+    def _deploy_to_host(self, host: str, compose_file: str):
+        """Deploy to a single host."""
+        logger.info(f"      Deploying to {host}...")
+        # TODO: Integrate with deploy-docker
+        pass
+
+    def _health_check(self, host: str) -> bool:
+        """Check if host is healthy."""
+        from vm_tool.health import check_http
+
+        try:
+            return check_http(f"http://{host}/health")
+        except:
+            return False

vm_tool/validation.py

@@ -0,0 +1,267 @@
+"""Deployment validation framework."""
+
+import logging
+from typing import List, Dict, Any, Callable, Optional
+from dataclasses import dataclass
+from enum import Enum
+
+logger = logging.getLogger(__name__)
+
+
+class ValidationStatus(Enum):
+    """Validation check status."""
+
+    PASSED = "passed"
+    FAILED = "failed"
+    SKIPPED = "skipped"
+    WARNING = "warning"
+
+
+@dataclass
+class ValidationResult:
+    """Result of a validation check."""
+
+    name: str
+    status: ValidationStatus
+    message: str
+    details: Optional[Dict[str, Any]] = None
+
+
+class DeploymentValidator:
+    """Validate deployment readiness and health."""
+
+    def __init__(self, host: str, port: int = 8000):
+        self.host = host
+        self.port = port
+        self.checks: List[Callable] = []
+        self.results: List[ValidationResult] = []
+
+    def add_check(self, check_func: Callable, name: str):
+        """Add a validation check."""
+        self.checks.append((name, check_func))
+
+    def validate_all(self) -> bool:
+        """Run all validation checks.
+
+        Returns:
+            True if all checks passed, False otherwise
+        """
+        self.results = []
+        all_passed = True
+
+        logger.info(f"🔍 Running {len(self.checks)} validation checks...")
+
+        for name, check_func in self.checks:
+            try:
+                result = check_func()
+                self.results.append(result)
+
+                if result.status == ValidationStatus.PASSED:
+                    logger.info(f"  ✅ {name}: {result.message}")
+                elif result.status == ValidationStatus.WARNING:
+                    logger.warning(f"  ⚠️  {name}: {result.message}")
+                elif result.status == ValidationStatus.FAILED:
+                    logger.error(f"  ❌ {name}: {result.message}")
+                    all_passed = False
+                else:  # SKIPPED
+                    logger.info(f"  ⏭️  {name}: {result.message}")
+
+            except Exception as e:
+                logger.error(f"  ❌ {name}: Check failed with error: {e}")
+                self.results.append(
+                    ValidationResult(
+                        name=name,
+                        status=ValidationStatus.FAILED,
+                        message=f"Check failed: {e}",
+                    )
+                )
+                all_passed = False
+
+        return all_passed
+
+    def check_port_open(self) -> ValidationResult:
+        """Check if application port is open."""
+        import socket
+
+        try:
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.settimeout(5)
+            result = sock.connect_ex((self.host, self.port))
+            sock.close()
+
+            if result == 0:
+                return ValidationResult(
+                    name="Port Check",
+                    status=ValidationStatus.PASSED,
+                    message=f"Port {self.port} is open",
+                )
+            else:
+                return ValidationResult(
+                    name="Port Check",
+                    status=ValidationStatus.FAILED,
+                    message=f"Port {self.port} is not accessible",
+                )
+        except Exception as e:
+            return ValidationResult(
+                name="Port Check",
+                status=ValidationStatus.FAILED,
+                message=f"Port check failed: {e}",
+            )
+
+    def check_http_response(self, endpoint: str = "/") -> ValidationResult:
+        """Check if HTTP endpoint responds."""
+        import requests
+
+        url = f"http://{self.host}:{self.port}{endpoint}"
+
+        try:
+            response = requests.get(url, timeout=10)
+
+            if response.status_code == 200:
+                return ValidationResult(
+                    name="HTTP Response",
+                    status=ValidationStatus.PASSED,
+                    message=f"Endpoint {endpoint} returned 200",
+                    details={"status_code": response.status_code},
+                )
+            else:
+                return ValidationResult(
+                    name="HTTP Response",
+                    status=ValidationStatus.WARNING,
+                    message=f"Endpoint {endpoint} returned {response.status_code}",
+                    details={"status_code": response.status_code},
+                )
+        except Exception as e:
+            return ValidationResult(
+                name="HTTP Response",
+                status=ValidationStatus.FAILED,
+                message=f"HTTP check failed: {e}",
+            )
+
+    def check_health_endpoint(self, endpoint: str = "/health") -> ValidationResult:
+        """Check health endpoint."""
+        import requests
+
+        url = f"http://{self.host}:{self.port}{endpoint}"
+
+        try:
+            response = requests.get(url, timeout=10)
+
+            if response.status_code == 200:
+                try:
+                    data = response.json()
+                    status = data.get("status", "unknown")
+
+                    if status == "healthy" or status == "ok":
+                        return ValidationResult(
+                            name="Health Check",
+                            status=ValidationStatus.PASSED,
+                            message="Application is healthy",
+                            details=data,
+                        )
+                    else:
+                        return ValidationResult(
+                            name="Health Check",
+                            status=ValidationStatus.WARNING,
+                            message=f"Health status: {status}",
+                            details=data,
+                        )
+                except:
+                    return ValidationResult(
+                        name="Health Check",
+                        status=ValidationStatus.PASSED,
+                        message="Health endpoint accessible",
+                    )
+            else:
+                return ValidationResult(
+                    name="Health Check",
+                    status=ValidationStatus.FAILED,
+                    message=f"Health endpoint returned {response.status_code}",
+                )
+        except Exception as e:
+            return ValidationResult(
+                name="Health Check",
+                status=ValidationStatus.FAILED,
+                message=f"Health check failed: {e}",
+            )
+
+    def check_database_connection(self, db_url: str) -> ValidationResult:
+        """Check database connectivity."""
+        # Placeholder - would implement actual DB connection check
+        return ValidationResult(
+            name="Database Connection",
+            status=ValidationStatus.SKIPPED,
+            message="Database check not configured",
+        )
+
+    def check_dependencies(self, dependencies: List[str]) -> ValidationResult:
+        """Check if required dependencies are available."""
+        # Placeholder - would check service dependencies
+        return ValidationResult(
+            name="Dependencies Check",
+            status=ValidationStatus.SKIPPED,
+            message="Dependency check not configured",
+        )
+
+    def generate_report(self) -> str:
+        """Generate validation report."""
+        passed = sum(1 for r in self.results if r.status == ValidationStatus.PASSED)
+        failed = sum(1 for r in self.results if r.status == ValidationStatus.FAILED)
+        warnings = sum(1 for r in self.results if r.status == ValidationStatus.WARNING)
+        skipped = sum(1 for r in self.results if r.status == ValidationStatus.SKIPPED)
+
+        report = f"""
+Deployment Validation Report
+============================
+Host: {self.host}:{self.port}
+Total Checks: {len(self.results)}
+
+Results:
+  ✅ Passed:  {passed}
+  ❌ Failed:  {failed}
+  ⚠️  Warnings: {warnings}
+  ⏭️  Skipped: {skipped}
+
+Details:
+"""
+        for result in self.results:
+            icon = {
+                ValidationStatus.PASSED: "✅",
+                ValidationStatus.FAILED: "❌",
+                ValidationStatus.WARNING: "⚠️",
+                ValidationStatus.SKIPPED: "⏭️",
+            }[result.status]
+
+            report += f"\n{icon} {result.name}: {result.message}"
+            if result.details:
+                report += f"\n   Details: {result.details}"
+
+        return report
+
+
+def validate_deployment(host: str, port: int = 8000) -> bool:
+    """Quick deployment validation.
+
+    Args:
+        host: Host to validate
+        port: Port to check
+
+    Returns:
+        True if validation passed, False otherwise
+    """
+    validator = DeploymentValidator(host, port)
+
+    # Add standard checks
+    validator.add_check(validator.check_port_open, "Port Accessibility")
+    validator.add_check(validator.check_http_response, "HTTP Response")
+    validator.add_check(
+        lambda: validator.check_health_endpoint("/health"), "Health Endpoint"
+    )
+
+    # Run validation
+    result = validator.validate_all()
+
+    # Print report
+    print(validator.generate_report())
+
+    return result

vm_tool/vm_setup/cleanup.yml

@@ -0,0 +1,27 @@
+- name: Cleanup VM
+  block:
+    - name: Remove GitHub credentials from git-credentials
+      file:
+        path: ~/.git-credentials
+        state: absent
+      become: yes
+      when: GITHUB_TOKEN is defined
+
+    - name: Clear Git credential helper configuration
+      shell: git config --global --unset credential.helper
+      become: yes
+      when: GITHUB_TOKEN is defined
+
+    - name: Unset environment variables
+      shell: |
+        unset GITHUB_PROJECT_URL
+        unset GITHUB_USERNAME
+        unset GITHUB_TOKEN
+        unset DOCKERHUB_USERNAME
+        unset DOCKERHUB_PASSWORD
+      environment:
+        GITHUB_PROJECT_URL: "{{ GITHUB_PROJECT_URL }}"
+        GITHUB_USERNAME: "{{ GITHUB_USERNAME }}"
+        GITHUB_TOKEN: "{{ GITHUB_TOKEN }}"
+        DOCKERHUB_USERNAME: "{{ DOCKERHUB_USERNAME }}"
+        DOCKERHUB_PASSWORD: "{{ DOCKERHUB_PASSWORD }}"

vm_tool/vm_setup/docker/create_docker_service.yml

@@ -0,0 +1,63 @@
+- name: Clean up Docker Environment and Set up Docker Service
+  block:
+    - name: Check if Docker Service File Exists
+      ansible.builtin.stat:
+        path: "{{ service_file_path }}"
+      register: service_file_stat
+    
+    - name: Stop project service and ignore errors
+      ansible.builtin.systemd:
+        name: project
+        state: stopped
+      ignore_errors: yes
+
+    # - name: Run Docker System Prune
+    #   ansible.builtin.command:
+    #     cmd: docker system prune -f
+    #   ignore_errors: yes
+
+    - name: Remove Existing Docker Service File
+      ansible.builtin.file:
+        path: "{{ service_file_path }}"
+        state: absent
+      when: service_file_stat.stat.exists
+
+    - name: Create Docker Service File
+      ansible.builtin.file:
+        path: "{{ service_file_path }}"
+        state: touch
+        mode: '0644'
+
+    - name: Check if Docker Compose File Path is Valid
+      ansible.builtin.stat:
+        path: "{{ project_dest_dir }}/{{ DOCKER_COMPOSE_FILE_PATH | default('docker-compose.yml') }}"
+      register: compose_file_stat
+
+    - name: Fail if Docker Compose File Path is Invalid
+      ansible.builtin.fail:
+        msg: "The specified Docker Compose file path '{{ project_dest_dir }}/{{ DOCKER_COMPOSE_FILE_PATH | default('docker-compose.yml') }}' does not exist."
+      when: not compose_file_stat.stat.exists
+
+    - name: Insert Docker Service Configuration
+      ansible.builtin.blockinfile:
+        path: "{{ service_file_path }}"
+        block: |
+          [Unit]
+          Description=Project Docker Container
+          After=docker.service
+
+          [Service]
+          Type=simple
+          WorkingDirectory={{ project_dest_dir }}
+          ExecStart={{ DEPLOY_COMMAND if DEPLOY_COMMAND is defined else ('docker compose -f ' + (DOCKER_COMPOSE_FILE_PATH | default('docker-compose.yml')) + (' --env-file ' + ENV_FILE_PATH if ENV_FILE_PATH is defined else '') + ' up -d') }}
+          Restart=always
+          RestartSec=10s
+
+          [Install]
+          WantedBy=multi-user.target
+
+    - name: Reload Systemd Daemon
+      ansible.builtin.systemd:
+        daemon_reload: yes
+
+  become: yes

vm_tool/vm_setup/docker/docker_setup.yml

@@ -0,0 +1,7 @@
+- name: Docker Setup Playbook
+  block:
+    - name: Adding Docker and Compose packages
+      include_tasks: docker/install_docker_and_compose.yml
+
+    - name: Log in to Docker Hub
+      include_tasks: docker/login_to_docker_hub.yml