vm-tool 1.0.32__py3-none-any.whl

examples/production-deploy.sh

@@ -0,0 +1,70 @@
+#!/bin/bash
+
+# Production Deployment Script
+# This script demonstrates a complete production deployment workflow using vm_tool
+
+set -e  # Exit on error
+
+echo "🚀 Starting Production Deployment"
+echo "=================================="
+
+# Configuration
+PROFILE="production"
+HOST="10.0.2.10"
+BACKUP_PATHS="/app /etc/nginx /var/www"
+
+# Step 1: Create backup before deployment
+echo ""
+echo "📦 Step 1: Creating backup..."
+vm_tool backup create \
+  --host $HOST \
+  --paths $BACKUP_PATHS
+
+# Step 2: Check for configuration drift
+echo ""
+echo "🔍 Step 2: Checking for configuration drift..."
+if ! vm_tool drift-check --host $HOST; then
+    echo "⚠️  Warning: Drift detected. Review changes before proceeding."
+    read -p "Continue anyway? (yes/no): " continue
+    if [ "$continue" != "yes" ]; then
+        echo "❌ Deployment cancelled"
+        exit 1
+    fi
+fi
+
+# Step 3: Dry-run deployment
+echo ""
+echo "🔍 Step 3: Running dry-run..."
+vm_tool deploy-docker --profile $PROFILE --dry-run
+
+# Step 4: Confirm deployment
+echo ""
+read -p "Proceed with deployment? (yes/no): " confirm
+if [ "$confirm" != "yes" ]; then
+    echo "❌ Deployment cancelled"
+    exit 1
+fi
+
+# Step 5: Deploy with health checks
+echo ""
+echo "🚀 Step 5: Deploying..."
+vm_tool deploy-docker \
+  --profile $PROFILE \
+  --health-port 8000 \
+  --health-url "http://$HOST:8000/health" \
+  --health-check "docker ps | grep web"
+
+# Step 6: Verify deployment
+echo ""
+echo "✅ Step 6: Verifying deployment..."
+vm_tool history --host $HOST --limit 1
+
+# Step 7: Final drift check
+echo ""
+echo "🔍 Step 7: Final drift check..."
+vm_tool drift-check --host $HOST
+
+echo ""
+echo "=================================="
+echo "✅ Production deployment complete!"
+echo "=================================="

examples/rollback.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+
+# Emergency Rollback Script
+
+set -e
+
+echo "🔄 Emergency Rollback"
+echo "===================="
+
+# Get host from argument or prompt
+HOST=${1:-}
+if [ -z "$HOST" ]; then
+    read -p "Enter host IP: " HOST
+fi
+
+# Show recent deployments
+echo ""
+echo "📜 Recent deployments for $HOST:"
+vm_tool history --host $HOST --limit 5
+
+# Get deployment ID
+echo ""
+read -p "Enter deployment ID to rollback to (or press Enter for previous): " DEPLOYMENT_ID
+
+# Confirm rollback
+echo ""
+echo "⚠️  WARNING: This will rollback the deployment on $HOST"
+read -p "Are you sure? (yes/no): " confirm
+
+if [ "$confirm" != "yes" ]; then
+    echo "❌ Rollback cancelled"
+    exit 1
+fi
+
+# Execute rollback
+echo ""
+echo "🔄 Rolling back..."
+if [ -z "$DEPLOYMENT_ID" ]; then
+    vm_tool rollback --host $HOST
+else
+    vm_tool rollback --host $HOST --to $DEPLOYMENT_ID
+fi
+
+# Verify
+echo ""
+echo "✅ Rollback complete. Current deployment:"
+vm_tool history --host $HOST --limit 1
+
+echo ""
+echo "🔍 Checking system health..."
+# Add your health check commands here
+# vm_tool drift-check --host $HOST

examples/setup.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+
+# Setup Script - Configure vm_tool for your environment
+
+echo "🔧 VM Tool Setup"
+echo "================"
+
+# Create development profile
+echo ""
+echo "Creating development profile..."
+vm_tool config create-profile dev \
+  --environment development \
+  --host 192.168.1.100 \
+  --user ubuntu \
+  --compose-file docker-compose.dev.yml
+
+# Create staging profile
+echo ""
+echo "Creating staging profile..."
+vm_tool config create-profile staging \
+  --environment staging \
+  --host 10.0.1.5 \
+  --user deploy \
+  --compose-file docker-compose.yml
+
+# Create production profile
+echo ""
+echo "Creating production profile..."
+vm_tool config create-profile production \
+  --environment production \
+  --host 10.0.2.10 \
+  --user prod \
+  --compose-file docker-compose.yml
+
+# Set defaults
+echo ""
+echo "Setting default configuration..."
+vm_tool config set default-user ubuntu
+vm_tool config set default-compose-file docker-compose.yml
+
+# List all profiles
+echo ""
+echo "📋 Configured profiles:"
+vm_tool config list-profiles
+
+echo ""
+echo "✅ Setup complete!"
+echo ""
+echo "Usage examples:"
+echo "  vm_tool deploy-docker --profile dev"
+echo "  vm_tool deploy-docker --profile staging --dry-run"
+echo "  vm_tool deploy-docker --profile production --health-port 8000"

examples/ssh_key_management.py

@@ -0,0 +1,22 @@
+"""
+Example: SSH Key Management for a VM.
+- Generates an SSH key pair (if not present), configures the VM for SSH access, and updates local SSH config.
+- Useful for preparing a VM for secure, passwordless SSH access.
+"""
+
+from vm_tool.ssh import SSHSetup
+
+
+def main():
+    ssh_setup = SSHSetup(
+        hostname="your_vm_hostname",
+        username="your_vm_username",
+        password="your_vm_password",
+        email="your_email_for_ssh_key",
+    )
+
+    ssh_setup.setup()
+
+
+if __name__ == "__main__":
+    main()

examples/version_check.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+# Check installed version of vm_tool
+vm_tool --version

vm_tool/alerting.py

@@ -0,0 +1,274 @@
+"""Alerting system with multiple notification channels."""
+
+import logging
+from typing import Dict, Any, List, Optional
+from enum import Enum
+from dataclasses import dataclass
+
+logger = logging.getLogger(__name__)
+
+
+class AlertSeverity(Enum):
+    """Alert severity levels."""
+
+    INFO = "info"
+    WARNING = "warning"
+    ERROR = "error"
+    CRITICAL = "critical"
+
+
+@dataclass
+class Alert:
+    """Alert message."""
+
+    title: str
+    message: str
+    severity: AlertSeverity
+    metadata: Optional[Dict[str, Any]] = None
+
+
+class AlertChannel:
+    """Base class for alert channels."""
+
+    def send(self, alert: Alert) -> bool:
+        """Send alert through this channel."""
+        raise NotImplementedError
+
+
+class SlackAlertChannel(AlertChannel):
+    """Send alerts to Slack."""
+
+    def __init__(self, webhook_url: str):
+        self.webhook_url = webhook_url
+
+    def send(self, alert: Alert) -> bool:
+        """Send alert to Slack."""
+        import requests
+
+        # Color based on severity
+        colors = {
+            AlertSeverity.INFO: "#36a64f",
+            AlertSeverity.WARNING: "#ff9900",
+            AlertSeverity.ERROR: "#ff0000",
+            AlertSeverity.CRITICAL: "#8b0000",
+        }
+
+        payload = {
+            "attachments": [
+                {
+                    "color": colors.get(alert.severity, "#808080"),
+                    "title": alert.title,
+                    "text": alert.message,
+                    "fields": [
+                        {
+                            "title": "Severity",
+                            "value": alert.severity.value.upper(),
+                            "short": True,
+                        }
+                    ],
+                }
+            ]
+        }
+
+        if alert.metadata:
+            for key, value in alert.metadata.items():
+                payload["attachments"][0]["fields"].append(
+                    {
+                        "title": key.replace("_", " ").title(),
+                        "value": str(value),
+                        "short": True,
+                    }
+                )
+
+        try:
+            response = requests.post(self.webhook_url, json=payload)
+            response.raise_for_status()
+            logger.info("Alert sent to Slack")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to send Slack alert: {e}")
+            return False
+
+
+class PagerDutyAlertChannel(AlertChannel):
+    """Send alerts to PagerDuty."""
+
+    def __init__(self, integration_key: str):
+        self.integration_key = integration_key
+
+    def send(self, alert: Alert) -> bool:
+        """Send alert to PagerDuty."""
+        import requests
+
+        # Map severity to PagerDuty severity
+        severity_map = {
+            AlertSeverity.INFO: "info",
+            AlertSeverity.WARNING: "warning",
+            AlertSeverity.ERROR: "error",
+            AlertSeverity.CRITICAL: "critical",
+        }
+
+        payload = {
+            "routing_key": self.integration_key,
+            "event_action": "trigger",
+            "payload": {
+                "summary": alert.title,
+                "severity": severity_map.get(alert.severity, "error"),
+                "source": "vm-tool",
+                "custom_details": alert.metadata or {},
+            },
+        }
+
+        try:
+            response = requests.post(
+                "https://events.pagerduty.com/v2/enqueue", json=payload
+            )
+            response.raise_for_status()
+            logger.info("Alert sent to PagerDuty")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to send PagerDuty alert: {e}")
+            return False
+
+
+class SMSAlertChannel(AlertChannel):
+    """Send alerts via SMS using Twilio."""
+
+    def __init__(
+        self, account_sid: str, auth_token: str, from_number: str, to_numbers: List[str]
+    ):
+        self.account_sid = account_sid
+        self.auth_token = auth_token
+        self.from_number = from_number
+        self.to_numbers = to_numbers
+
+    def send(self, alert: Alert) -> bool:
+        """Send alert via SMS."""
+        try:
+            from twilio.rest import Client
+
+            client = Client(self.account_sid, self.auth_token)
+
+            # Format message
+            message = f"[{alert.severity.value.upper()}] {alert.title}\n{alert.message}"
+
+            # Send to all numbers
+            for number in self.to_numbers:
+                client.messages.create(body=message, from_=self.from_number, to=number)
+
+            logger.info(f"Alert sent via SMS to {len(self.to_numbers)} recipients")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to send SMS alert: {e}")
+            return False
+
+
+class EmailAlertChannel(AlertChannel):
+    """Send alerts via email."""
+
+    def __init__(
+        self,
+        smtp_host: str,
+        smtp_port: int,
+        from_email: str,
+        to_emails: List[str],
+        smtp_user: Optional[str] = None,
+        smtp_password: Optional[str] = None,
+    ):
+        self.smtp_host = smtp_host
+        self.smtp_port = smtp_port
+        self.from_email = from_email
+        self.to_emails = to_emails
+        self.smtp_user = smtp_user
+        self.smtp_password = smtp_password
+
+    def send(self, alert: Alert) -> bool:
+        """Send alert via email."""
+        from vm_tool.notifications import EmailNotifier
+
+        notifier = EmailNotifier(
+            smtp_host=self.smtp_host,
+            smtp_port=self.smtp_port,
+            smtp_user=self.smtp_user,
+            smtp_password=self.smtp_password,
+            from_email=self.from_email,
+        )
+
+        subject = f"[{alert.severity.value.upper()}] {alert.title}"
+
+        return notifier.send_email(
+            to_emails=self.to_emails, subject=subject, body=alert.message
+        )
+
+
+class AlertingSystem:
+    """Centralized alerting system."""
+
+    def __init__(self):
+        self.channels: List[AlertChannel] = []
+
+    def add_channel(self, channel: AlertChannel):
+        """Add an alert channel."""
+        self.channels.append(channel)
+
+    def send_alert(self, alert: Alert):
+        """Send alert through all channels."""
+        logger.info(f"Sending alert: {alert.title} ({alert.severity.value})")
+
+        for channel in self.channels:
+            try:
+                channel.send(alert)
+            except Exception as e:
+                logger.error(f"Failed to send alert through channel: {e}")
+
+    def deployment_failed(self, host: str, error: str, **metadata):
+        """Send deployment failure alert."""
+        alert = Alert(
+            title="Deployment Failed",
+            message=f"Deployment to {host} failed: {error}",
+            severity=AlertSeverity.ERROR,
+            metadata={"host": host, "error": error, **metadata},
+        )
+        self.send_alert(alert)
+
+    def deployment_succeeded(self, host: str, duration: float, **metadata):
+        """Send deployment success notification."""
+        alert = Alert(
+            title="Deployment Successful",
+            message=f"Deployment to {host} completed in {duration:.2f}s",
+            severity=AlertSeverity.INFO,
+            metadata={"host": host, "duration": duration, **metadata},
+        )
+        self.send_alert(alert)
+
+    def health_check_failed(self, host: str, check_type: str, **metadata):
+        """Send health check failure alert."""
+        alert = Alert(
+            title="Health Check Failed",
+            message=f"Health check '{check_type}' failed on {host}",
+            severity=AlertSeverity.WARNING,
+            metadata={"host": host, "check_type": check_type, **metadata},
+        )
+        self.send_alert(alert)
+
+    def critical_error(self, title: str, message: str, **metadata):
+        """Send critical error alert."""
+        alert = Alert(
+            title=title,
+            message=message,
+            severity=AlertSeverity.CRITICAL,
+            metadata=metadata,
+        )
+        self.send_alert(alert)
+
+
+# Global alerting system instance
+_alerting_system = None
+
+
+def get_alerting_system() -> AlertingSystem:
+    """Get global alerting system instance."""
+    global _alerting_system
+    if _alerting_system is None:
+        _alerting_system = AlertingSystem()
+    return _alerting_system

vm_tool/audit.py

@@ -0,0 +1,118 @@
+"""Audit logging for all deployment operations."""
+
+import logging
+import json
+from typing import Dict, Any, Optional
+from datetime import datetime
+from pathlib import Path
+from enum import Enum
+
+logger = logging.getLogger(__name__)
+
+
+class AuditEventType(Enum):
+    """Types of audit events."""
+
+    DEPLOYMENT_STARTED = "deployment.started"
+    DEPLOYMENT_SUCCESS = "deployment.success"
+    DEPLOYMENT_FAILED = "deployment.failed"
+    ROLLBACK_STARTED = "rollback.started"
+    ROLLBACK_SUCCESS = "rollback.success"
+    CONFIG_CHANGED = "config.changed"
+    SECRET_ACCESSED = "secret.accessed"
+    USER_LOGIN = "user.login"
+    PERMISSION_DENIED = "permission.denied"
+
+
+class AuditLogger:
+    """Centralized audit logging system."""
+
+    def __init__(self, audit_dir: str = ".vm_tool/audit"):
+        self.audit_dir = Path(audit_dir)
+        self.audit_dir.mkdir(parents=True, exist_ok=True)
+        self.audit_file = self.audit_dir / "audit.jsonl"
+
+    def log_event(
+        self,
+        event_type: AuditEventType,
+        user: str,
+        action: str,
+        resource: str,
+        success: bool = True,
+        metadata: Optional[Dict[str, Any]] = None,
+    ):
+        """Log an audit event."""
+        event = {
+            "timestamp": datetime.utcnow().isoformat() + "Z",
+            "event_type": event_type.value,
+            "user": user,
+            "action": action,
+            "resource": resource,
+            "success": success,
+            "metadata": metadata or {},
+        }
+
+        # Append to audit log
+        with open(self.audit_file, "a") as f:
+            f.write(json.dumps(event) + "\n")
+
+        logger.info(
+            f"Audit: {user} {action} {resource} - {'success' if success else 'failed'}"
+        )
+
+    def get_audit_trail(self, limit: int = 100) -> list:
+        """Get recent audit events."""
+        if not self.audit_file.exists():
+            return []
+
+        events = []
+        with open(self.audit_file) as f:
+            for line in f:
+                events.append(json.loads(line))
+
+        return events[-limit:]
+
+    def search_events(
+        self,
+        user: Optional[str] = None,
+        event_type: Optional[str] = None,
+        start_time: Optional[datetime] = None,
+        end_time: Optional[datetime] = None,
+    ) -> list:
+        """Search audit events with filters."""
+        events = self.get_audit_trail(limit=10000)
+
+        filtered = []
+        for event in events:
+            if user and event.get("user") != user:
+                continue
+            if event_type and event.get("event_type") != event_type:
+                continue
+            if start_time:
+                event_time = datetime.fromisoformat(
+                    event["timestamp"].replace("Z", "+00:00")
+                )
+                if event_time < start_time:
+                    continue
+            if end_time:
+                event_time = datetime.fromisoformat(
+                    event["timestamp"].replace("Z", "+00:00")
+                )
+                if event_time > end_time:
+                    continue
+
+            filtered.append(event)
+
+        return filtered
+
+
+# Global audit logger
+_audit_logger = None
+
+
+def get_audit_logger() -> AuditLogger:
+    """Get global audit logger instance."""
+    global _audit_logger
+    if _audit_logger is None:
+        _audit_logger = AuditLogger()
+    return _audit_logger