vm-tool 1.0.32__py3-none-any.whl

vm_tool/cloud.py

@@ -0,0 +1,125 @@
+"""Multi-cloud support framework (AWS, GCP, Azure)."""
+
+import logging
+from typing import Optional, Dict, Any
+from abc import ABC, abstractmethod
+
+logger = logging.getLogger(__name__)
+
+
+class CloudProvider(ABC):
+    """Base class for cloud providers."""
+
+    @abstractmethod
+    def deploy_vm(self, config: Dict[str, Any]) -> str:
+        """Deploy VM and return instance ID."""
+        pass
+
+    @abstractmethod
+    def get_vm_status(self, instance_id: str) -> str:
+        """Get VM status."""
+        pass
+
+    @abstractmethod
+    def terminate_vm(self, instance_id: str) -> bool:
+        """Terminate VM."""
+        pass
+
+
+class AWSProvider(CloudProvider):
+    """AWS cloud provider (requires boto3)."""
+
+    def __init__(self, region: str = "us-east-1"):
+        self.region = region
+        logger.info(f"AWS provider initialized (region: {region})")
+        # TODO: Initialize boto3 client
+
+    def deploy_vm(self, config: Dict[str, Any]) -> str:
+        """Deploy EC2 instance."""
+        logger.info("Deploying AWS EC2 instance...")
+        # TODO: Implement with boto3
+        return "i-placeholder"
+
+    def get_vm_status(self, instance_id: str) -> str:
+        """Get EC2 instance status."""
+        # TODO: Implement with boto3
+        return "running"
+
+    def terminate_vm(self, instance_id: str) -> bool:
+        """Terminate EC2 instance."""
+        logger.info(f"Terminating EC2 instance: {instance_id}")
+        # TODO: Implement with boto3
+        return True
+
+
+class GCPProvider(CloudProvider):
+    """GCP cloud provider (requires google-cloud-compute)."""
+
+    def __init__(self, project_id: str, zone: str = "us-central1-a"):
+        self.project_id = project_id
+        self.zone = zone
+        logger.info(f"GCP provider initialized (project: {project_id}, zone: {zone})")
+        # TODO: Initialize GCP client
+
+    def deploy_vm(self, config: Dict[str, Any]) -> str:
+        """Deploy GCE instance."""
+        logger.info("Deploying GCP Compute Engine instance...")
+        # TODO: Implement with google-cloud-compute
+        return "gcp-instance-placeholder"
+
+    def get_vm_status(self, instance_id: str) -> str:
+        """Get GCE instance status."""
+        # TODO: Implement
+        return "RUNNING"
+
+    def terminate_vm(self, instance_id: str) -> bool:
+        """Terminate GCE instance."""
+        logger.info(f"Terminating GCE instance: {instance_id}")
+        # TODO: Implement
+        return True
+
+
+class AzureProvider(CloudProvider):
+    """Azure cloud provider (requires azure-mgmt-compute)."""
+
+    def __init__(self, subscription_id: str, resource_group: str):
+        self.subscription_id = subscription_id
+        self.resource_group = resource_group
+        logger.info(f"Azure provider initialized (subscription: {subscription_id})")
+        # TODO: Initialize Azure client
+
+    def deploy_vm(self, config: Dict[str, Any]) -> str:
+        """Deploy Azure VM."""
+        logger.info("Deploying Azure VM...")
+        # TODO: Implement with azure-mgmt-compute
+        return "azure-vm-placeholder"
+
+    def get_vm_status(self, instance_id: str) -> str:
+        """Get Azure VM status."""
+        # TODO: Implement
+        return "running"
+
+    def terminate_vm(self, instance_id: str) -> bool:
+        """Terminate Azure VM."""
+        logger.info(f"Terminating Azure VM: {instance_id}")
+        # TODO: Implement
+        return True
+
+
+class MultiCloudManager:
+    """Manage deployments across multiple clouds."""
+
+    def __init__(self):
+        self.providers: Dict[str, CloudProvider] = {}
+
+    def register_provider(self, name: str, provider: CloudProvider):
+        """Register a cloud provider."""
+        self.providers[name] = provider
+        logger.info(f"Registered cloud provider: {name}")
+
+    def deploy(self, provider_name: str, config: Dict[str, Any]) -> str:
+        """Deploy to specified cloud provider."""
+        if provider_name not in self.providers:
+            raise ValueError(f"Unknown provider: {provider_name}")
+
+        return self.providers[provider_name].deploy_vm(config)

vm_tool/completion.py

@@ -0,0 +1,200 @@
+"""CLI auto-completion support for bash, zsh, and fish shells."""
+
+import os
+import sys
+
+
+def generate_bash_completion() -> str:
+    """Generate bash completion script."""
+    return """# vm_tool bash completion
+
+_vm_tool_completion() {
+    local cur prev opts
+    COMPREPLY=()
+    cur="${COMP_WORDS[COMP_CWORD]}"
+    prev="${COMP_WORDS[COMP_CWORD-1]}"
+    
+    # Main commands
+    local commands="config history rollback drift-check backup setup setup-cloud setup-k8s setup-monitoring deploy-docker generate-pipeline --help --version --verbose --debug"
+    
+    # Config subcommands
+    local config_commands="set get unset list create-profile list-profiles delete-profile"
+    
+    # Backup subcommands
+    local backup_commands="create list restore"
+    
+    if [ $COMP_CWORD -eq 1 ]; then
+        COMPREPLY=( $(compgen -W "${commands}" -- ${cur}) )
+        return 0
+    fi
+    
+    case "${prev}" in
+        config)
+            COMPREPLY=( $(compgen -W "${config_commands}" -- ${cur}) )
+            return 0
+            ;;
+        backup)
+            COMPREPLY=( $(compgen -W "${backup_commands}" -- ${cur}) )
+            return 0
+            ;;
+        --profile)
+            # Complete with available profiles
+            local profiles=$(vm_tool config list-profiles 2>/dev/null | grep -v "^Available" | awk '{print $1}')
+            COMPREPLY=( $(compgen -W "${profiles}" -- ${cur}) )
+            return 0
+            ;;
+        --host|--user|--compose-file)
+            # File/path completion
+            COMPREPLY=( $(compgen -f -- ${cur}) )
+            return 0
+            ;;
+    esac
+}
+
+complete -F _vm_tool_completion vm_tool
+"""
+
+
+def generate_zsh_completion() -> str:
+    """Generate zsh completion script."""
+    return """#compdef vm_tool
+
+_vm_tool() {
+    local -a commands
+    commands=(
+        'config:Manage configuration'
+        'history:Show deployment history'
+        'rollback:Rollback to previous deployment'
+        'drift-check:Check for configuration drift'
+        'backup:Backup and restore operations'
+        'setup:Setup VM with Docker and deploy'
+        'setup-cloud:Setup cloud VMs'
+        'setup-k8s:Install K3s Kubernetes cluster'
+        'setup-monitoring:Install Prometheus and Grafana'
+        'deploy-docker:Deploy using Docker Compose'
+        'generate-pipeline:Generate CI/CD pipeline configuration'
+    )
+    
+    local -a config_commands
+    config_commands=(
+        'set:Set a config value'
+        'get:Get a config value'
+        'unset:Unset a config value'
+        'list:List all config values'
+        'create-profile:Create a deployment profile'
+        'list-profiles:List all profiles'
+        'delete-profile:Delete a profile'
+    )
+    
+    local -a backup_commands
+    backup_commands=(
+        'create:Create a backup'
+        'list:List backups'
+        'restore:Restore a backup'
+    )
+    
+    _arguments -C \\
+        '1: :->command' \\
+        '*::arg:->args'
+    
+    case $state in
+        command)
+            _describe 'vm_tool commands' commands
+            ;;
+        args)
+            case $words[1] in
+                config)
+                    _describe 'config commands' config_commands
+                    ;;
+                backup)
+                    _describe 'backup commands' backup_commands
+                    ;;
+            esac
+            ;;
+    esac
+}
+
+_vm_tool "$@"
+"""
+
+
+def generate_fish_completion() -> str:
+    """Generate fish completion script."""
+    return """# vm_tool fish completion
+
+# Main commands
+complete -c vm_tool -f -n '__fish_use_subcommand' -a 'config' -d 'Manage configuration'
+complete -c vm_tool -f -n '__fish_use_subcommand' -a 'history' -d 'Show deployment history'
+complete -c vm_tool -f -n '__fish_use_subcommand' -a 'rollback' -d 'Rollback to previous deployment'
+complete -c vm_tool -f -n '__fish_use_subcommand' -a 'drift-check' -d 'Check for configuration drift'
+complete -c vm_tool -f -n '__fish_use_subcommand' -a 'backup' -d 'Backup and restore operations'
+complete -c vm_tool -f -n '__fish_use_subcommand' -a 'setup' -d 'Setup VM with Docker and deploy'
+complete -c vm_tool -f -n '__fish_use_subcommand' -a 'setup-cloud' -d 'Setup cloud VMs'
+complete -c vm_tool -f -n '__fish_use_subcommand' -a 'setup-k8s' -d 'Install K3s Kubernetes cluster'
+complete -c vm_tool -f -n '__fish_use_subcommand' -a 'setup-monitoring' -d 'Install Prometheus and Grafana'
+complete -c vm_tool -f -n '__fish_use_subcommand' -a 'deploy-docker' -d 'Deploy using Docker Compose'
+complete -c vm_tool -f -n '__fish_use_subcommand' -a 'generate-pipeline' -d 'Generate CI/CD pipeline'
+
+# Config subcommands
+complete -c vm_tool -f -n '__fish_seen_subcommand_from config' -a 'set' -d 'Set a config value'
+complete -c vm_tool -f -n '__fish_seen_subcommand_from config' -a 'get' -d 'Get a config value'
+complete -c vm_tool -f -n '__fish_seen_subcommand_from config' -a 'unset' -d 'Unset a config value'
+complete -c vm_tool -f -n '__fish_seen_subcommand_from config' -a 'list' -d 'List all config values'
+complete -c vm_tool -f -n '__fish_seen_subcommand_from config' -a 'create-profile' -d 'Create a deployment profile'
+complete -c vm_tool -f -n '__fish_seen_subcommand_from config' -a 'list-profiles' -d 'List all profiles'
+complete -c vm_tool -f -n '__fish_seen_subcommand_from config' -a 'delete-profile' -d 'Delete a profile'
+
+# Backup subcommands
+complete -c vm_tool -f -n '__fish_seen_subcommand_from backup' -a 'create' -d 'Create a backup'
+complete -c vm_tool -f -n '__fish_seen_subcommand_from backup' -a 'list' -d 'List backups'
+complete -c vm_tool -f -n '__fish_seen_subcommand_from backup' -a 'restore' -d 'Restore a backup'
+
+# Global options
+complete -c vm_tool -l help -d 'Show help message'
+complete -c vm_tool -l version -d 'Show version'
+complete -c vm_tool -s v -l verbose -d 'Enable verbose output'
+complete -c vm_tool -s d -l debug -d 'Enable debug logging'
+"""
+
+
+def install_completion(shell: str = "bash") -> str:
+    """Install completion script for specified shell."""
+    if shell == "bash":
+        script = generate_bash_completion()
+        path = "/etc/bash_completion.d/vm_tool"
+        alt_path = os.path.expanduser("~/.bash_completion.d/vm_tool")
+    elif shell == "zsh":
+        script = generate_zsh_completion()
+        path = "/usr/local/share/zsh/site-functions/_vm_tool"
+        alt_path = os.path.expanduser("~/.zsh/completion/_vm_tool")
+    elif shell == "fish":
+        script = generate_fish_completion()
+        path = "/usr/share/fish/vendor_completions.d/vm_tool.fish"
+        alt_path = os.path.expanduser("~/.config/fish/completions/vm_tool.fish")
+    else:
+        raise ValueError(f"Unsupported shell: {shell}")
+
+    # Try system path first, fall back to user path
+    try:
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, "w") as f:
+            f.write(script)
+        return path
+    except PermissionError:
+        os.makedirs(os.path.dirname(alt_path), exist_ok=True)
+        with open(alt_path, "w") as f:
+            f.write(script)
+        return alt_path
+
+
+def print_completion(shell: str = "bash"):
+    """Print completion script to stdout."""
+    if shell == "bash":
+        print(generate_bash_completion())
+    elif shell == "zsh":
+        print(generate_zsh_completion())
+    elif shell == "fish":
+        print(generate_fish_completion())
+    else:
+        print(f"Error: Unsupported shell: {shell}", file=sys.stderr)
+        sys.exit(1)

vm_tool/compliance.py

@@ -0,0 +1,104 @@
+"""Compliance scanning and security checks."""
+
+import logging
+from typing import List, Dict, Any
+from dataclasses import dataclass
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ComplianceIssue:
+    """Compliance issue details."""
+
+    severity: str  # "critical", "high", "medium", "low"
+    category: str
+    description: str
+    remediation: str
+
+
+class ComplianceScanner:
+    """Scan deployments for compliance issues."""
+
+    def __init__(self):
+        self.issues: List[ComplianceIssue] = []
+
+    def scan_docker_compose(self, compose_file: str) -> List[ComplianceIssue]:
+        """Scan docker-compose file for compliance."""
+        logger.info(f"Scanning {compose_file} for compliance issues")
+        issues = []
+
+        # TODO: Implement actual scanning
+        # - Check for privileged containers
+        # - Check for host network mode
+        # - Check for exposed sensitive ports
+        # - Check for missing resource limits
+
+        return issues
+
+    def scan_secrets(self, secrets_config: Dict[str, Any]) -> List[ComplianceIssue]:
+        """Scan secrets configuration."""
+        logger.info("Scanning secrets configuration")
+        issues = []
+
+        # TODO: Check for weak encryption, exposed secrets, etc.
+
+        return issues
+
+    def generate_compliance_report(self) -> str:
+        """Generate compliance report."""
+        if not self.issues:
+            return "✅ No compliance issues found"
+
+        report = f"Compliance Scan Report\n{'='*50}\n"
+        report += f"Total Issues: {len(self.issues)}\n\n"
+
+        for issue in self.issues:
+            report += f"[{issue.severity.upper()}] {issue.category}\n"
+            report += f"  {issue.description}\n"
+            report += f"  Remediation: {issue.remediation}\n\n"
+
+        return report
+
+
+class CostOptimizer:
+    """Cost optimization recommendations."""
+
+    def analyze_resource_usage(self, metrics: Dict[str, Any]) -> List[str]:
+        """Analyze resource usage and provide recommendations."""
+        logger.info("Analyzing resource usage for cost optimization")
+        recommendations = []
+
+        # TODO: Implement actual analysis
+        # - Check for over-provisioned resources
+        # - Identify idle instances
+        # - Suggest reserved instances
+        # - Recommend spot instances
+
+        return recommendations
+
+
+class DisasterRecovery:
+    """Disaster recovery automation."""
+
+    def create_dr_plan(self, config: Dict[str, Any]) -> Dict[str, Any]:
+        """Create disaster recovery plan."""
+        logger.info("Creating disaster recovery plan")
+
+        plan = {
+            "backup_frequency": "daily",
+            "retention_days": 30,
+            "failover_region": "us-west-2",
+            "rto_minutes": 60,  # Recovery Time Objective
+            "rpo_minutes": 15,  # Recovery Point Objective
+        }
+
+        # TODO: Implement actual DR planning
+
+        return plan
+
+    def execute_failover(self, primary_region: str, dr_region: str) -> bool:
+        """Execute failover to DR region."""
+        logger.info(f"Executing failover: {primary_region} -> {dr_region}")
+        # TODO: Implement actual failover
+        return True

vm_tool/config.py

@@ -0,0 +1,92 @@
+"""Configuration management for vm_tool."""
+
+import json
+import logging
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class Config:
+    """Manages vm_tool configuration and profiles."""
+
+    def __init__(self):
+        self.config_dir = Path.home() / ".vm_tool"
+        self.config_file = self.config_dir / "config.json"
+        self.profiles_file = self.config_dir / "profiles.json"
+        self._ensure_config_dir()
+
+    def _ensure_config_dir(self):
+        """Create config directory if it doesn't exist."""
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+
+    def _load(self, file_path: Path) -> Dict[str, Any]:
+        """Load JSON config file."""
+        if not file_path.exists():
+            return {}
+        try:
+            with open(file_path, "r") as f:
+                return json.load(f)
+        except json.JSONDecodeError:
+            logger.warning(f"Invalid JSON in {file_path}, returning empty config")
+            return {}
+
+    def _save(self, data: Dict[str, Any], file_path: Path):
+        """Save data to JSON config file."""
+        with open(file_path, "w") as f:
+            json.dump(data, f, indent=2)
+
+    def set(self, key: str, value: Any):
+        """Set a configuration value."""
+        config = self._load(self.config_file)
+        config[key] = value
+        self._save(config, self.config_file)
+        logger.info(f"Set config: {key} = {value}")
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """Get a configuration value."""
+        config = self._load(self.config_file)
+        return config.get(key, default)
+
+    def unset(self, key: str):
+        """Remove a configuration value."""
+        config = self._load(self.config_file)
+        if key in config:
+            del config[key]
+            self._save(config, self.config_file)
+            logger.info(f"Unset config: {key}")
+        else:
+            logger.warning(f"Config key not found: {key}")
+
+    def list_all(self) -> Dict[str, Any]:
+        """List all configuration values."""
+        return self._load(self.config_file)
+
+    # Profile management
+    def create_profile(self, name: str, environment: str = "development", **kwargs):
+        """Create a deployment profile with environment tag."""
+        profiles = self._load(self.profiles_file)
+        profile_data = {"environment": environment, **kwargs}
+        profiles[name] = profile_data
+        self._save(profiles, self.profiles_file)
+        logger.info(f"Created profile: {name} (environment: {environment})")
+
+    def get_profile(self, name: str) -> Optional[Dict[str, Any]]:
+        """Get a deployment profile."""
+        profiles = self._load(self.profiles_file)
+        return profiles.get(name)
+
+    def list_profiles(self) -> Dict[str, Dict[str, Any]]:
+        """List all profiles."""
+        return self._load(self.profiles_file)
+
+    def delete_profile(self, name: str):
+        """Delete a deployment profile."""
+        profiles = self._load(self.profiles_file)
+        if name in profiles:
+            del profiles[name]
+            self._save(profiles, self.profiles_file)
+            logger.info(f"Deleted profile: {name}")
+        else:
+            logger.warning(f"Profile not found: {name}")

vm_tool/drift.py

@@ -0,0 +1,98 @@
+"""Drift detection to catch manual server changes."""
+
+import hashlib
+import json
+import logging
+import subprocess
+from pathlib import Path
+from typing import Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class DriftDetector:
+    """Detects configuration drift on deployed servers."""
+
+    def __init__(self, state_dir: Optional[Path] = None):
+        if state_dir is None:
+            state_dir = Path.home() / ".vm_tool"
+        self.state_dir = state_dir
+        self.drift_file = self.state_dir / "drift_state.json"
+        self._ensure_state_dir()
+
+    def _ensure_state_dir(self):
+        """Create state directory if it doesn't exist."""
+        self.state_dir.mkdir(parents=True, exist_ok=True)
+
+    def _load_drift_state(self) -> Dict:
+        """Load drift state from file."""
+        if not self.drift_file.exists():
+            return {}
+        try:
+            with open(self.drift_file, "r") as f:
+                return json.load(f)
+        except json.JSONDecodeError:
+            logger.warning("Invalid drift state file")
+            return {}
+
+    def _save_drift_state(self, state: Dict):
+        """Save drift state to file."""
+        with open(self.drift_file, "w") as f:
+            json.dump(state, f, indent=2)
+
+    def record_file_state(self, host: str, file_path: str, content_hash: str):
+        """Record the expected state of a file."""
+        state = self._load_drift_state()
+        if host not in state:
+            state[host] = {}
+        state[host][file_path] = content_hash
+        self._save_drift_state(state)
+
+    def check_drift(self, host: str, user: str = "ubuntu") -> List[Dict]:
+        """Check for drift on a host."""
+        state = self._load_drift_state()
+        if host not in state:
+            logger.info(f"No baseline state for {host}")
+            return []
+
+        drifts = []
+        for file_path, expected_hash in state[host].items():
+            actual_hash = self._get_remote_file_hash(host, user, file_path)
+            if actual_hash and actual_hash != expected_hash:
+                drifts.append(
+                    {
+                        "file": file_path,
+                        "expected": expected_hash,
+                        "actual": actual_hash,
+                        "status": "modified",
+                    }
+                )
+            elif not actual_hash:
+                drifts.append(
+                    {
+                        "file": file_path,
+                        "expected": expected_hash,
+                        "actual": None,
+                        "status": "deleted",
+                    }
+                )
+
+        return drifts
+
+    def _get_remote_file_hash(
+        self, host: str, user: str, file_path: str
+    ) -> Optional[str]:
+        """Get hash of a file on remote server."""
+        try:
+            result = subprocess.run(
+                ["ssh", f"{user}@{host}", f"sha256sum {file_path}"],
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            if result.returncode == 0:
+                # sha256sum output: "hash  filename"
+                return result.stdout.split()[0]
+        except Exception as e:
+            logger.error(f"Failed to get remote file hash: {e}")
+        return None