vm-tool 1.0.32__py3-none-any.whl

vm_tool/strategies/ab_testing.py

@@ -0,0 +1,258 @@
+"""A/B testing and traffic splitting strategies."""
+
+import logging
+from typing import Dict, Any, List, Optional
+from dataclasses import dataclass
+from enum import Enum
+
+logger = logging.getLogger(__name__)
+
+
+class VariantType(Enum):
+    """A/B test variant type."""
+
+    CONTROL = "control"  # Original version
+    VARIANT_A = "variant_a"
+    VARIANT_B = "variant_b"
+    VARIANT_C = "variant_c"
+
+
+@dataclass
+class Variant:
+    """A/B test variant configuration."""
+
+    name: str
+    host: str
+    traffic_percentage: float
+    description: Optional[str] = None
+
+
+class ABTestDeployment:
+    """Manage A/B testing deployments."""
+
+    def __init__(self, variants: List[Variant]):
+        """Initialize A/B test deployment.
+
+        Args:
+            variants: List of test variants
+        """
+        self.variants = variants
+        self._validate_traffic_percentages()
+
+    def _validate_traffic_percentages(self):
+        """Validate that traffic percentages sum to 100."""
+        total = sum(v.traffic_percentage for v in self.variants)
+        if abs(total - 100.0) > 0.01:  # Allow small floating point errors
+            raise ValueError(f"Traffic percentages must sum to 100%, got {total}%")
+
+    def deploy(self, compose_files: Dict[str, str]) -> Dict[str, Any]:
+        """Deploy A/B test variants.
+
+        Args:
+            compose_files: Mapping of variant name to compose file
+
+        Returns:
+            Deployment result
+        """
+        logger.info("🧪 Starting A/B test deployment")
+        logger.info(f"   Variants: {len(self.variants)}")
+
+        result = {
+            "success": False,
+            "deployed_variants": [],
+            "failed_variants": [],
+        }
+
+        # Deploy each variant
+        for variant in self.variants:
+            logger.info(
+                f"📦 Deploying variant '{variant.name}' ({variant.traffic_percentage}%)"
+            )
+            logger.info(f"   Host: {variant.host}")
+
+            compose_file = compose_files.get(variant.name)
+            if not compose_file:
+                logger.warning(
+                    f"   ⚠️  No compose file for variant '{variant.name}', skipping"
+                )
+                continue
+
+            try:
+                self._deploy_variant(variant, compose_file)
+                result["deployed_variants"].append(variant.name)
+                logger.info(f"   ✅ Variant '{variant.name}' deployed")
+            except Exception as e:
+                logger.error(f"   ❌ Variant '{variant.name}' failed: {e}")
+                result["failed_variants"].append(variant.name)
+
+        # Configure traffic splitting
+        if not result["failed_variants"]:
+            logger.info("🔄 Configuring traffic splitting...")
+            self._configure_traffic_split()
+            result["success"] = True
+
+        return result
+
+    def _deploy_variant(self, variant: Variant, compose_file: str):
+        """Deploy a single variant."""
+        # TODO: Integrate with deploy-docker
+        logger.info(f"      Deploying {compose_file} to {variant.host}")
+        pass
+
+    def _configure_traffic_split(self):
+        """Configure load balancer for traffic splitting."""
+        # This would configure the load balancer to split traffic
+        # based on variant percentages
+        for variant in self.variants:
+            logger.info(
+                f"   {variant.name}: {variant.traffic_percentage}% → {variant.host}"
+            )
+        # TODO: Implement actual LB configuration
+        pass
+
+    def get_variant_metrics(self, variant_name: str) -> Dict[str, Any]:
+        """Get metrics for a specific variant.
+
+        Args:
+            variant_name: Name of the variant
+
+        Returns:
+            Variant metrics
+        """
+        # This would fetch actual metrics from monitoring system
+        return {
+            "variant": variant_name,
+            "requests": 1000,
+            "success_rate": 99.5,
+            "avg_response_time": 120,
+            "conversion_rate": 5.2,
+        }
+
+    def compare_variants(self) -> Dict[str, Any]:
+        """Compare metrics across all variants.
+
+        Returns:
+            Comparison results
+        """
+        logger.info("📊 Comparing variant metrics...")
+
+        comparison = {
+            "variants": {},
+            "winner": None,
+        }
+
+        best_conversion = 0
+        best_variant = None
+
+        for variant in self.variants:
+            metrics = self.get_variant_metrics(variant.name)
+            comparison["variants"][variant.name] = metrics
+
+            conversion = metrics.get("conversion_rate", 0)
+            if conversion > best_conversion:
+                best_conversion = conversion
+                best_variant = variant.name
+
+        comparison["winner"] = best_variant
+
+        logger.info(f"   Winner: {best_variant} ({best_conversion}% conversion)")
+
+        return comparison
+
+    def promote_winner(self, winner_name: str) -> bool:
+        """Promote winning variant to 100% traffic.
+
+        Args:
+            winner_name: Name of winning variant
+
+        Returns:
+            True if promotion successful
+        """
+        logger.info(f"🏆 Promoting variant '{winner_name}' to 100% traffic")
+
+        # Update traffic percentages
+        for variant in self.variants:
+            if variant.name == winner_name:
+                variant.traffic_percentage = 100.0
+            else:
+                variant.traffic_percentage = 0.0
+
+        # Reconfigure traffic split
+        self._configure_traffic_split()
+
+        logger.info("✅ Winner promoted successfully")
+        return True
+
+
+class TrafficSplitter:
+    """Manage traffic splitting across multiple backends."""
+
+    def __init__(self, backends: Dict[str, str]):
+        """Initialize traffic splitter.
+
+        Args:
+            backends: Mapping of backend name to host
+        """
+        self.backends = backends
+        self.traffic_weights: Dict[str, float] = {}
+
+    def set_weights(self, weights: Dict[str, float]):
+        """Set traffic weights for backends.
+
+        Args:
+            weights: Mapping of backend name to weight (0-100)
+        """
+        total = sum(weights.values())
+        if abs(total - 100.0) > 0.01:
+            raise ValueError(f"Weights must sum to 100%, got {total}%")
+
+        self.traffic_weights = weights
+        self._apply_weights()
+
+    def _apply_weights(self):
+        """Apply traffic weights to load balancer."""
+        logger.info("🔄 Applying traffic weights:")
+        for backend, weight in self.traffic_weights.items():
+            host = self.backends.get(backend, "unknown")
+            logger.info(f"   {backend}: {weight}% → {host}")
+
+        # TODO: Implement actual LB weight configuration
+        pass
+
+    def gradual_shift(
+        self,
+        from_backend: str,
+        to_backend: str,
+        increment: float = 10.0,
+        interval: int = 60,
+    ):
+        """Gradually shift traffic from one backend to another.
+
+        Args:
+            from_backend: Source backend
+            to_backend: Target backend
+            increment: Percentage to shift per step
+            interval: Seconds between shifts
+        """
+        logger.info(f"🔄 Gradual traffic shift: {from_backend} → {to_backend}")
+
+        current_from = self.traffic_weights.get(from_backend, 100.0)
+        current_to = self.traffic_weights.get(to_backend, 0.0)
+
+        import time
+
+        while current_from > 0:
+            shift_amount = min(increment, current_from)
+            current_from -= shift_amount
+            current_to += shift_amount
+
+            self.traffic_weights[from_backend] = current_from
+            self.traffic_weights[to_backend] = current_to
+
+            self._apply_weights()
+
+            if current_from > 0:
+                logger.info(f"   Waiting {interval}s before next shift...")
+                time.sleep(interval)
+
+        logger.info("✅ Traffic shift complete")

vm_tool/strategies/blue_green.py

@@ -0,0 +1,227 @@
+"""Blue-Green deployment strategy for zero-downtime deployments."""
+
+import logging
+import time
+from typing import Optional, Dict, Any
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+class BlueGreenDeployment:
+    """Manage blue-green deployments for zero-downtime updates."""
+
+    def __init__(
+        self,
+        blue_host: str,
+        green_host: str,
+        load_balancer_host: Optional[str] = None,
+        health_check_url: str = "/health",
+        health_check_timeout: int = 300,
+    ):
+        """Initialize blue-green deployment.
+
+        Args:
+            blue_host: Blue environment host
+            green_host: Green environment host
+            load_balancer_host: Load balancer host (if using external LB)
+            health_check_url: Health check endpoint
+            health_check_timeout: Max time to wait for health checks (seconds)
+        """
+        self.blue_host = blue_host
+        self.green_host = green_host
+        self.load_balancer_host = load_balancer_host
+        self.health_check_url = health_check_url
+        self.health_check_timeout = health_check_timeout
+        self.current_active = "blue"  # Track which environment is active
+
+    def deploy(
+        self,
+        compose_file: str,
+        target_env: Optional[str] = None,
+        auto_switch: bool = True,
+    ) -> Dict[str, Any]:
+        """Execute blue-green deployment.
+
+        Args:
+            compose_file: Path to docker-compose file
+            target_env: Target environment ('blue' or 'green'), auto-detect if None
+            auto_switch: Automatically switch traffic after successful deployment
+
+        Returns:
+            Deployment result with status and details
+        """
+        # Determine target environment (deploy to inactive)
+        if target_env is None:
+            target_env = "green" if self.current_active == "blue" else "blue"
+
+        target_host = self.green_host if target_env == "green" else self.blue_host
+
+        logger.info(f"🔵🟢 Starting blue-green deployment to {target_env} environment")
+        logger.info(f"   Target: {target_host}")
+        logger.info(f"   Current active: {self.current_active}")
+
+        result = {
+            "success": False,
+            "target_env": target_env,
+            "target_host": target_host,
+            "previous_active": self.current_active,
+            "switched": False,
+        }
+
+        try:
+            # Step 1: Deploy to target environment
+            logger.info(f"📦 Deploying to {target_env} environment...")
+            self._deploy_to_host(target_host, compose_file)
+
+            # Step 2: Run health checks
+            logger.info(f"🏥 Running health checks on {target_env}...")
+            if not self._wait_for_health(target_host):
+                raise Exception(f"Health checks failed on {target_env} environment")
+
+            logger.info(f"✅ {target_env.capitalize()} environment is healthy")
+
+            # Step 3: Switch traffic (if auto_switch enabled)
+            if auto_switch:
+                logger.info(f"🔄 Switching traffic to {target_env}...")
+                self._switch_traffic(target_env)
+                result["switched"] = True
+                self.current_active = target_env
+                logger.info(f"✅ Traffic switched to {target_env}")
+            else:
+                logger.info(f"⏸️  Auto-switch disabled. Manual switch required.")
+
+            result["success"] = True
+            return result
+
+        except Exception as e:
+            logger.error(f"❌ Blue-green deployment failed: {e}")
+            result["error"] = str(e)
+            return result
+
+    def switch_traffic(self, target_env: str) -> bool:
+        """Manually switch traffic to specified environment.
+
+        Args:
+            target_env: Target environment ('blue' or 'green')
+
+        Returns:
+            True if switch successful, False otherwise
+        """
+        try:
+            self._switch_traffic(target_env)
+            self.current_active = target_env
+            logger.info(f"✅ Traffic switched to {target_env}")
+            return True
+        except Exception as e:
+            logger.error(f"❌ Failed to switch traffic: {e}")
+            return False
+
+    def rollback(self) -> bool:
+        """Rollback to previous environment.
+
+        Returns:
+            True if rollback successful, False otherwise
+        """
+        previous_env = "green" if self.current_active == "blue" else "blue"
+        logger.info(f"🔄 Rolling back to {previous_env} environment...")
+        return self.switch_traffic(previous_env)
+
+    def _deploy_to_host(self, host: str, compose_file: str):
+        """Deploy application to specified host."""
+        # This would use the existing deploy-docker functionality
+        # For now, placeholder for integration
+        logger.info(f"   Deploying {compose_file} to {host}")
+        # TODO: Integrate with vm_tool deploy-docker
+        pass
+
+    def _wait_for_health(self, host: str) -> bool:
+        """Wait for host to become healthy.
+
+        Args:
+            host: Host to check
+
+        Returns:
+            True if healthy within timeout, False otherwise
+        """
+        from vm_tool.health import check_http
+
+        start_time = time.time()
+        url = f"http://{host}{self.health_check_url}"
+
+        while time.time() - start_time < self.health_check_timeout:
+            try:
+                if check_http(url):
+                    return True
+            except Exception as e:
+                logger.debug(f"Health check failed: {e}")
+
+            time.sleep(5)
+
+        return False
+
+    def _switch_traffic(self, target_env: str):
+        """Switch load balancer traffic to target environment.
+
+        Args:
+            target_env: Target environment ('blue' or 'green')
+        """
+        if self.load_balancer_host:
+            # External load balancer (e.g., AWS ALB, nginx)
+            logger.info(f"   Updating load balancer: {self.load_balancer_host}")
+            # TODO: Implement load balancer update
+            # This would depend on the LB type (AWS, nginx, HAProxy, etc.)
+        else:
+            # Internal traffic switching (e.g., update DNS, update nginx config)
+            logger.info(f"   Switching internal traffic to {target_env}")
+            # TODO: Implement internal traffic switching
+
+        # Placeholder - actual implementation would update LB/DNS
+        logger.info(f"   Traffic switch to {target_env} complete")
+
+
+class BlueGreenConfig:
+    """Configuration for blue-green deployments."""
+
+    def __init__(self, config_file: str = "blue-green.yml"):
+        self.config_file = Path(config_file)
+        self.config = self._load_config()
+
+    def _load_config(self) -> Dict[str, Any]:
+        """Load blue-green configuration."""
+        import yaml
+
+        if not self.config_file.exists():
+            return self._default_config()
+
+        with open(self.config_file) as f:
+            return yaml.safe_load(f)
+
+    def _default_config(self) -> Dict[str, Any]:
+        """Return default blue-green configuration."""
+        return {
+            "blue": {
+                "host": "10.0.1.10",
+                "port": 8000,
+            },
+            "green": {
+                "host": "10.0.1.11",
+                "port": 8000,
+            },
+            "load_balancer": {
+                "host": "10.0.1.1",
+                "type": "nginx",  # or 'aws-alb', 'haproxy'
+            },
+            "health_check": {
+                "url": "/health",
+                "timeout": 300,
+                "interval": 5,
+            },
+        }
+
+    def save(self):
+        """Save configuration to file."""
+        import yaml
+
+        with open(self.config_file, "w") as f:
+            yaml.dump(self.config, f, default_flow_style=False)