vm-tool 1.0.32__py3-none-any.whl

vm_tool/history.py

@@ -0,0 +1,131 @@
+"""Deployment history tracking and rollback functionality."""
+
+import json
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class DeploymentHistory:
+    """Manages deployment history for rollback capability."""
+
+    def __init__(self, history_dir: Optional[Path] = None):
+        if history_dir is None:
+            history_dir = Path.home() / ".vm_tool"
+        self.history_dir = history_dir
+        self.history_file = self.history_dir / "deployment_history.json"
+        self._ensure_history_dir()
+
+    def _ensure_history_dir(self):
+        """Create history directory if it doesn't exist."""
+        self.history_dir.mkdir(parents=True, exist_ok=True)
+
+    def _load_history(self) -> List[Dict[str, Any]]:
+        """Load deployment history from file."""
+        if not self.history_file.exists():
+            return []
+        try:
+            with open(self.history_file, "r") as f:
+                return json.load(f)
+        except json.JSONDecodeError:
+            logger.warning("Invalid history file, returning empty history")
+            return []
+
+    def _save_history(self, history: List[Dict[str, Any]]):
+        """Save deployment history to file."""
+        with open(self.history_file, "w") as f:
+            json.dump(history, f, indent=2)
+
+    def record_deployment(
+        self,
+        host: str,
+        compose_file: str,
+        compose_hash: str,
+        git_commit: Optional[str] = None,
+        service_name: str = "default",
+        status: str = "success",
+        error: Optional[str] = None,
+    ) -> str:
+        """Record a deployment in history and return deployment ID."""
+        history = self._load_history()
+
+        deployment_id = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+        deployment_record = {
+            "id": deployment_id,
+            "timestamp": datetime.now().isoformat(),
+            "host": host,
+            "service_name": service_name,
+            "compose_file": compose_file,
+            "compose_hash": compose_hash,
+            "git_commit": git_commit,
+            "status": status,
+            "error": error,
+        }
+
+        history.append(deployment_record)
+
+        # Keep only last 100 deployments
+        if len(history) > 100:
+            history = history[-100:]
+
+        self._save_history(history)
+        logger.info(f"Recorded deployment: {deployment_id}")
+
+        return deployment_id
+
+    def get_history(
+        self, host: Optional[str] = None, limit: int = 10
+    ) -> List[Dict[str, Any]]:
+        """Get deployment history, optionally filtered by host."""
+        history = self._load_history()
+
+        if host:
+            history = [d for d in history if d.get("host") == host]
+
+        # Return most recent first
+        history.reverse()
+
+        return history[:limit]
+
+    def get_deployment(self, deployment_id: str) -> Optional[Dict[str, Any]]:
+        """Get a specific deployment by ID."""
+        history = self._load_history()
+        for deployment in history:
+            if deployment.get("id") == deployment_id:
+                return deployment
+        return None
+
+    def get_previous_deployment(
+        self, host: str, service_name: str = "default"
+    ) -> Optional[Dict[str, Any]]:
+        """Get the previous successful deployment for a host/service."""
+        history = self._load_history()
+
+        # Filter by host and service, get successful deployments
+        matching = [
+            d
+            for d in history
+            if d.get("host") == host
+            and d.get("service_name") == service_name
+            and d.get("status") == "success"
+        ]
+
+        if len(matching) >= 2:
+            # Return second-to-last (previous deployment)
+            return matching[-2]
+
+        return None
+
+    def get_rollback_info(
+        self, host: str, deployment_id: Optional[str] = None
+    ) -> Optional[Dict[str, Any]]:
+        """Get rollback information for a deployment."""
+        if deployment_id:
+            return self.get_deployment(deployment_id)
+        else:
+            # Get previous deployment
+            return self.get_previous_deployment(host)

vm_tool/kubernetes.py

@@ -0,0 +1,89 @@
+"""Kubernetes native support framework."""
+
+import logging
+from typing import Dict, Any, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class KubernetesDeployment:
+    """Kubernetes deployment manager (requires kubectl/kubernetes python client)."""
+
+    def __init__(self, kubeconfig: Optional[str] = None, namespace: str = "default"):
+        self.kubeconfig = kubeconfig
+        self.namespace = namespace
+        logger.info(f"Kubernetes deployment initialized (namespace: {namespace})")
+        # TODO: Initialize kubernetes client
+
+    def deploy_helm_chart(
+        self, chart_name: str, release_name: str, values: Dict[str, Any]
+    ) -> bool:
+        """Deploy Helm chart."""
+        logger.info(f"Deploying Helm chart: {chart_name} as {release_name}")
+        # TODO: Implement with helm or kubernetes client
+        return True
+
+    def deploy_manifest(self, manifest_file: str) -> bool:
+        """Deploy Kubernetes manifest."""
+        logger.info(f"Deploying manifest: {manifest_file}")
+        # TODO: Implement with kubectl or kubernetes client
+        return True
+
+    def get_pod_status(self, pod_name: str) -> str:
+        """Get pod status."""
+        # TODO: Implement
+        return "Running"
+
+    def scale_deployment(self, deployment_name: str, replicas: int) -> bool:
+        """Scale deployment."""
+        logger.info(f"Scaling {deployment_name} to {replicas} replicas")
+        # TODO: Implement
+        return True
+
+    def rollback_deployment(
+        self, deployment_name: str, revision: Optional[int] = None
+    ) -> bool:
+        """Rollback deployment."""
+        logger.info(f"Rolling back deployment: {deployment_name}")
+        # TODO: Implement
+        return True
+
+
+class ServiceMeshIntegration:
+    """Service mesh integration (Istio/Linkerd)."""
+
+    def __init__(self, mesh_type: str = "istio"):
+        self.mesh_type = mesh_type
+        logger.info(f"Service mesh integration: {mesh_type}")
+
+    def configure_traffic_split(self, service: str, versions: Dict[str, int]) -> bool:
+        """Configure traffic splitting between versions."""
+        logger.info(f"Configuring traffic split for {service}: {versions}")
+        # TODO: Implement Istio VirtualService or Linkerd TrafficSplit
+        return True
+
+    def enable_mtls(self, namespace: str) -> bool:
+        """Enable mutual TLS."""
+        logger.info(f"Enabling mTLS for namespace: {namespace}")
+        # TODO: Implement
+        return True
+
+
+class GitOpsIntegration:
+    """GitOps integration (ArgoCD/Flux)."""
+
+    def __init__(self, gitops_tool: str = "argocd"):
+        self.gitops_tool = gitops_tool
+        logger.info(f"GitOps integration: {gitops_tool}")
+
+    def create_application(self, name: str, repo_url: str, path: str) -> bool:
+        """Create GitOps application."""
+        logger.info(f"Creating GitOps app: {name} from {repo_url}/{path}")
+        # TODO: Implement ArgoCD or Flux application creation
+        return True
+
+    def sync_application(self, name: str) -> bool:
+        """Sync GitOps application."""
+        logger.info(f"Syncing GitOps app: {name}")
+        # TODO: Implement
+        return True

vm_tool/metrics.py

@@ -0,0 +1,183 @@
+"""Metrics collection and export for deployments."""
+
+import logging
+import time
+from typing import Dict, Any, Optional
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class DeploymentMetrics:
+    """Metrics for a deployment."""
+
+    deployment_id: str
+    host: str
+    start_time: float = field(default_factory=time.time)
+    end_time: Optional[float] = None
+    duration: Optional[float] = None
+    success: bool = False
+    error: Optional[str] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    def finish(self, success: bool = True, error: Optional[str] = None):
+        """Mark deployment as finished."""
+        self.end_time = time.time()
+        self.duration = self.end_time - self.start_time
+        self.success = success
+        self.error = error
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "deployment_id": self.deployment_id,
+            "host": self.host,
+            "start_time": datetime.fromtimestamp(self.start_time).isoformat(),
+            "end_time": (
+                datetime.fromtimestamp(self.end_time).isoformat()
+                if self.end_time
+                else None
+            ),
+            "duration_seconds": self.duration,
+            "success": self.success,
+            "error": self.error,
+            **self.metadata,
+        }
+
+
+class MetricsCollector:
+    """Collect and export deployment metrics."""
+
+    def __init__(self, export_dir: str = ".vm_tool/metrics"):
+        self.export_dir = Path(export_dir)
+        self.export_dir.mkdir(parents=True, exist_ok=True)
+        self.current_deployment: Optional[DeploymentMetrics] = None
+
+    def start_deployment(
+        self, deployment_id: str, host: str, **metadata
+    ) -> DeploymentMetrics:
+        """Start tracking a deployment."""
+        self.current_deployment = DeploymentMetrics(
+            deployment_id=deployment_id, host=host, metadata=metadata
+        )
+        logger.info(f"📊 Started tracking deployment: {deployment_id}")
+        return self.current_deployment
+
+    def finish_deployment(self, success: bool = True, error: Optional[str] = None):
+        """Finish tracking current deployment."""
+        if self.current_deployment:
+            self.current_deployment.finish(success, error)
+            self._export_metrics(self.current_deployment)
+            logger.info(
+                f"📊 Deployment metrics recorded: {self.current_deployment.duration:.2f}s"
+            )
+
+    def _export_metrics(self, metrics: DeploymentMetrics):
+        """Export metrics to file."""
+        import json
+
+        # Export to JSON
+        metrics_file = self.export_dir / f"{metrics.deployment_id}.json"
+        with open(metrics_file, "w") as f:
+            json.dump(metrics.to_dict(), f, indent=2)
+
+        # Append to metrics log
+        log_file = self.export_dir / "deployments.jsonl"
+        with open(log_file, "a") as f:
+            f.write(json.dumps(metrics.to_dict()) + "\n")
+
+    def export_prometheus(
+        self, metrics: DeploymentMetrics, output_file: str = "metrics.prom"
+    ):
+        """Export metrics in Prometheus format."""
+        prom_file = self.export_dir / output_file
+
+        with open(prom_file, "w") as f:
+            # Deployment duration
+            f.write(f"# HELP deployment_duration_seconds Time taken for deployment\n")
+            f.write(f"# TYPE deployment_duration_seconds gauge\n")
+            f.write(
+                f'deployment_duration_seconds{{host="{metrics.host}",deployment_id="{metrics.deployment_id}"}} {metrics.duration or 0}\n\n'
+            )
+
+            # Deployment success
+            f.write(
+                f"# HELP deployment_success Whether deployment succeeded (1) or failed (0)\n"
+            )
+            f.write(f"# TYPE deployment_success gauge\n")
+            f.write(
+                f'deployment_success{{host="{metrics.host}",deployment_id="{metrics.deployment_id}"}} {1 if metrics.success else 0}\n\n'
+            )
+
+            # Deployment timestamp
+            f.write(f"# HELP deployment_timestamp_seconds Deployment start time\n")
+            f.write(f"# TYPE deployment_timestamp_seconds gauge\n")
+            f.write(
+                f'deployment_timestamp_seconds{{host="{metrics.host}",deployment_id="{metrics.deployment_id}"}} {metrics.start_time}\n'
+            )
+
+        logger.info(f"📊 Prometheus metrics exported to {prom_file}")
+
+    def get_stats(self, limit: int = 100) -> Dict[str, Any]:
+        """Get deployment statistics."""
+        import json
+
+        log_file = self.export_dir / "deployments.jsonl"
+        if not log_file.exists():
+            return {"total": 0, "success": 0, "failed": 0}
+
+        deployments = []
+        with open(log_file) as f:
+            for line in f:
+                deployments.append(json.loads(line))
+
+        # Get recent deployments
+        recent = deployments[-limit:]
+
+        total = len(recent)
+        success = sum(1 for d in recent if d.get("success"))
+        failed = total - success
+
+        durations = [d["duration_seconds"] for d in recent if d.get("duration_seconds")]
+        avg_duration = sum(durations) / len(durations) if durations else 0
+
+        return {
+            "total_deployments": total,
+            "successful": success,
+            "failed": failed,
+            "success_rate": (success / total * 100) if total > 0 else 0,
+            "average_duration_seconds": avg_duration,
+            "recent_deployments": recent[-10:],  # Last 10
+        }
+
+    def print_stats(self):
+        """Print deployment statistics."""
+        stats = self.get_stats()
+
+        print("\n📊 Deployment Statistics")
+        print("=" * 50)
+        print(f"Total Deployments: {stats['total_deployments']}")
+        print(f"Successful: {stats['successful']} ({stats['success_rate']:.1f}%)")
+        print(f"Failed: {stats['failed']}")
+        print(f"Average Duration: {stats['average_duration_seconds']:.2f}s")
+        print("\nRecent Deployments:")
+        for d in stats["recent_deployments"]:
+            status = "✅" if d["success"] else "❌"
+            print(
+                f"  {status} {d['deployment_id']} - {d['host']} - {d['duration_seconds']:.2f}s"
+            )
+
+
+# Global metrics collector instance
+_metrics_collector = None
+
+
+def get_metrics_collector() -> MetricsCollector:
+    """Get global metrics collector instance."""
+    global _metrics_collector
+    if _metrics_collector is None:
+        _metrics_collector = MetricsCollector()
+    return _metrics_collector

vm_tool/notifications.py

@@ -0,0 +1,152 @@
+"""Email notification support for deployment events."""
+
+import logging
+import smtplib
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+from typing import List, Optional
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+
+
+class EmailNotifier:
+    """Send email notifications for deployment events."""
+
+    def __init__(
+        self,
+        smtp_host: str = "localhost",
+        smtp_port: int = 587,
+        smtp_user: Optional[str] = None,
+        smtp_password: Optional[str] = None,
+        from_email: str = "vm-tool@localhost",
+        use_tls: bool = True,
+    ):
+        self.smtp_host = smtp_host
+        self.smtp_port = smtp_port
+        self.smtp_user = smtp_user
+        self.smtp_password = smtp_password
+        self.from_email = from_email
+        self.use_tls = use_tls
+
+    def send_email(
+        self, to_emails: List[str], subject: str, body: str, html: bool = False
+    ) -> bool:
+        """Send email notification.
+
+        Args:
+            to_emails: List of recipient email addresses
+            subject: Email subject
+            body: Email body
+            html: If True, send as HTML email
+
+        Returns:
+            True if email sent successfully, False otherwise
+        """
+        try:
+            msg = MIMEMultipart("alternative")
+            msg["Subject"] = subject
+            msg["From"] = self.from_email
+            msg["To"] = ", ".join(to_emails)
+            msg["Date"] = datetime.utcnow().strftime("%a, %d %b %Y %H:%M:%S +0000")
+
+            if html:
+                msg.attach(MIMEText(body, "html"))
+            else:
+                msg.attach(MIMEText(body, "plain"))
+
+            # Connect to SMTP server
+            if self.use_tls:
+                server = smtplib.SMTP(self.smtp_host, self.smtp_port)
+                server.starttls()
+            else:
+                server = smtplib.SMTP(self.smtp_host, self.smtp_port)
+
+            # Login if credentials provided
+            if self.smtp_user and self.smtp_password:
+                server.login(self.smtp_user, self.smtp_password)
+
+            # Send email
+            server.sendmail(self.from_email, to_emails, msg.as_string())
+            server.quit()
+
+            logger.info(f"Email sent successfully to {', '.join(to_emails)}")
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to send email: {e}")
+            return False
+
+    def deployment_success(
+        self, to_emails: List[str], host: str, duration: float, **kwargs
+    ):
+        """Send deployment success notification."""
+        subject = f"✅ Deployment Successful - {host}"
+        body = f"""
+Deployment completed successfully!
+
+Host: {host}
+Duration: {duration:.2f} seconds
+Time: {datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S UTC')}
+
+Additional Details:
+{self._format_kwargs(kwargs)}
+"""
+        return self.send_email(to_emails, subject, body)
+
+    def deployment_failed(self, to_emails: List[str], host: str, error: str, **kwargs):
+        """Send deployment failure notification."""
+        subject = f"❌ Deployment Failed - {host}"
+        body = f"""
+Deployment failed!
+
+Host: {host}
+Error: {error}
+Time: {datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S UTC')}
+
+Additional Details:
+{self._format_kwargs(kwargs)}
+
+Please check the logs for more information.
+"""
+        return self.send_email(to_emails, subject, body)
+
+    def rollback_success(self, to_emails: List[str], host: str, **kwargs):
+        """Send rollback success notification."""
+        subject = f"🔄 Rollback Successful - {host}"
+        body = f"""
+Rollback completed successfully!
+
+Host: {host}
+Time: {datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S UTC')}
+
+Additional Details:
+{self._format_kwargs(kwargs)}
+"""
+        return self.send_email(to_emails, subject, body)
+
+    def health_check_failed(
+        self, to_emails: List[str], host: str, check_type: str, **kwargs
+    ):
+        """Send health check failure notification."""
+        subject = f"⚠️ Health Check Failed - {host}"
+        body = f"""
+Health check failed!
+
+Host: {host}
+Check Type: {check_type}
+Time: {datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S UTC')}
+
+Additional Details:
+{self._format_kwargs(kwargs)}
+
+Please investigate immediately.
+"""
+        return self.send_email(to_emails, subject, body)
+
+    @staticmethod
+    def _format_kwargs(kwargs: dict) -> str:
+        """Format kwargs as readable string."""
+        if not kwargs:
+            return "None"
+        return "\n".join(f"  {k}: {v}" for k, v in kwargs.items())

vm_tool/plugins.py

@@ -0,0 +1,119 @@
+"""Plugin system for extensibility."""
+
+import logging
+from typing import Dict, Any, Callable, List
+from pathlib import Path
+import importlib.util
+
+logger = logging.getLogger(__name__)
+
+
+class Plugin:
+    """Base plugin class."""
+
+    def __init__(self, name: str, version: str):
+        self.name = name
+        self.version = version
+
+    def on_deployment_start(self, context: Dict[str, Any]):
+        """Called before deployment starts."""
+        pass
+
+    def on_deployment_success(self, context: Dict[str, Any]):
+        """Called after successful deployment."""
+        pass
+
+    def on_deployment_failure(self, context: Dict[str, Any]):
+        """Called after failed deployment."""
+        pass
+
+
+class PluginManager:
+    """Manage plugins."""
+
+    def __init__(self, plugin_dir: str = ".vm_tool/plugins"):
+        self.plugin_dir = Path(plugin_dir)
+        self.plugin_dir.mkdir(parents=True, exist_ok=True)
+        self.plugins: List[Plugin] = []
+
+    def load_plugin(self, plugin_path: str):
+        """Load a plugin from file."""
+        logger.info(f"Loading plugin: {plugin_path}")
+
+        # TODO: Implement plugin loading
+        # - Load Python module
+        # - Instantiate plugin class
+        # - Register hooks
+
+    def register_plugin(self, plugin: Plugin):
+        """Register a plugin."""
+        self.plugins.append(plugin)
+        logger.info(f"Registered plugin: {plugin.name} v{plugin.version}")
+
+    def trigger_hook(self, hook_name: str, context: Dict[str, Any]):
+        """Trigger plugin hooks."""
+        for plugin in self.plugins:
+            try:
+                hook = getattr(plugin, hook_name, None)
+                if hook and callable(hook):
+                    hook(context)
+            except Exception as e:
+                logger.error(f"Plugin {plugin.name} hook {hook_name} failed: {e}")
+
+
+# Integration stubs for nice-to-have features
+class SlackBot:
+    """Slack bot integration."""
+
+    def __init__(self, bot_token: str):
+        self.bot_token = bot_token
+        logger.info("Slack bot initialized")
+
+    def send_message(self, channel: str, message: str):
+        """Send message to Slack channel."""
+        logger.info(f"Sending to #{channel}: {message}")
+        # TODO: Implement with slack_sdk
+
+
+class DiscordIntegration:
+    """Discord integration."""
+
+    def __init__(self, webhook_url: str):
+        self.webhook_url = webhook_url
+        logger.info("Discord integration initialized")
+
+    def send_notification(self, message: str):
+        """Send notification to Discord."""
+        logger.info(f"Discord notification: {message}")
+        # TODO: Implement with discord.py
+
+
+class TerraformProvider:
+    """Terraform provider stub."""
+
+    def __init__(self):
+        logger.info("Terraform provider initialized")
+        # TODO: Implement Terraform provider
+        # This would be a separate Go project
+
+
+class GitHubApp:
+    """GitHub App integration."""
+
+    def __init__(self, app_id: str, private_key: str):
+        self.app_id = app_id
+        logger.info(f"GitHub App initialized: {app_id}")
+        # TODO: Implement with PyGithub
+
+    def create_deployment(self, repo: str, ref: str):
+        """Create GitHub deployment."""
+        logger.info(f"Creating GitHub deployment: {repo}@{ref}")
+        # TODO: Implement
+
+
+class VSCodeExtension:
+    """VS Code extension stub."""
+
+    # This would be a separate TypeScript/JavaScript project
+    # Placeholder for documentation
+    pass