mantatech-sdk 0.5b0.dev65__py3-none-any.whl

manta/cli/commands/install.py

@@ -0,0 +1,346 @@
+"""Installation helper commands for Manta CLI."""
+
+import subprocess
+import sys
+from typing import List, Optional
+
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.prompt import Confirm
+from rich.table import Table
+
+from ..component_detector import ComponentDetector
+
+
+class InstallCommands:
+    """Handle installation-related CLI commands."""
+
+    def __init__(self, detector: ComponentDetector, console: Optional[Console] = None):
+        self.detector = detector
+        self.console = console
+
+    def print(self, *args, **kwargs):
+        """Print with console if available."""
+        self.console.print(*args, **kwargs)
+
+    def print_error(self, message: str):
+        """Print error message."""
+        self.console.print(f"[red]Error:[/red] {message}")
+
+    def print_success(self, message: str):
+        """Print success message."""
+        self.console.print(f"[green]Success:[/green] {message}")
+
+    def print_warning(self, message: str):
+        """Print warning message."""
+        self.console.print(f"[yellow]Warning:[/yellow] {message}")
+
+    def handle(self, args) -> int:
+        """Handle installation commands."""
+        if hasattr(args, "install_command") and args.install_command:
+            if args.install_command == "wizard":
+                return self.run_installation_wizard()
+            elif args.install_command == "check":
+                return self.check_requirements()
+            elif args.install_command == "component":
+                # Handle component installation with name
+                if hasattr(args, "name") and args.name:
+                    return self.install_component(args.name)
+                else:
+                    self.print_error("Component name is required")
+                    return 1
+            elif args.install_command == "sdk":
+                return self.install_component("sdk")
+            elif args.install_command == "admin":
+                return self.install_component("admin")
+            elif args.install_command == "node":
+                return self.install_component("node")
+            elif args.install_command == "all":
+                return self.install_all_components()
+            else:
+                self.print_error(f"Unknown install command: {args.install_command}")
+                return 1
+        else:
+            # Show installation help
+            return self.show_installation_help()
+
+    def show_installation_help(self) -> int:
+        """Show installation help and current status."""
+        self.print("📦 Manta Installation Guide")
+        self.print("=" * 30)
+
+        # Refresh detection
+        self.detector.refresh()
+
+        # Show current status
+        table = Table(title="Component Status")
+        table.add_column("Component", style="cyan")
+        table.add_column("Status", style="green")
+        table.add_column("Install Command", style="magenta")
+
+        for comp_name in self.detector.list_components():
+            comp_info = self.detector.get_component_info(comp_name)
+            if comp_info:
+                status = "✅ Installed" if comp_info.installed else "❌ Not Installed"
+                install_cmd = (
+                    self.detector.get_installation_command(comp_name)
+                    if not comp_info.installed
+                    else "-"
+                )
+                table.add_row(comp_info.name, status, install_cmd)
+
+        self.console.print(table)
+
+        # Show available commands
+        self.print("\n💡 Available Commands:")
+        self.print("  • manta install wizard     - Interactive installation wizard")
+        self.print("  • manta install check      - Check system requirements")
+        self.print("  • manta install sdk        - Install Manta SDK")
+        self.print("  • manta install admin      - Install Manta Admin")
+        self.print("  • manta install node       - Install Manta Node")
+        self.print("  • manta install all        - Install all components")
+
+        return 0
+
+    def run_installation_wizard(self) -> int:
+        """Run interactive installation wizard."""
+        self.print("🧙 Manta Installation Wizard")
+        self.print("=" * 30)
+
+        # Check requirements first
+        self.print("\n1️⃣  Checking system requirements...")
+        if not self._check_python_version():
+            return 1
+
+        if not self._check_pip():
+            return 1
+
+        self.print_success("System requirements met!")
+
+        # Detect missing components
+        self.detector.refresh()
+        summary = self.detector.get_status_summary()
+
+        if not summary["missing"]:
+            self.print_success("\n✅ All components are already installed!")
+            return 0
+
+        # Ask what to install
+        self.print(f"\n2️⃣  Found {len(summary['missing'])} missing component(s):")
+        for comp in summary["missing"]:
+            self.print(f"  • {comp}")
+
+        if Confirm.ask("\nWould you like to install all missing components?"):
+            return self._install_components(summary["missing"])
+        else:
+            # Let user select specific components
+            to_install = []
+            for comp in summary["missing"]:
+                if Confirm.ask(f"Install {comp}?"):
+                    to_install.append(comp)
+
+            if to_install:
+                return self._install_components(to_install)
+            else:
+                self.print("No components selected for installation.")
+                return 0
+
+    def check_requirements(self) -> int:
+        """Check system requirements."""
+        self.print("🔍 Checking System Requirements")
+        self.print("=" * 35)
+
+        all_good = True
+
+        # Check Python version
+        if not self._check_python_version():
+            all_good = False
+
+        # Check pip
+        if not self._check_pip():
+            all_good = False
+
+        # Check git
+        if not self._check_git():
+            all_good = False
+
+        # Check Docker (optional)
+        self._check_docker()
+
+        if all_good:
+            self.print_success("\n✅ All requirements met!")
+        else:
+            self.print_error(
+                "\n❌ Some requirements are not met. Please install missing dependencies."
+            )
+            return 1
+
+        return 0
+
+    def install_component(self, component: str) -> int:
+        """Install a specific component."""
+        comp_info = self.detector.get_component_info(component)
+
+        if not comp_info:
+            self.print_error(f"Unknown component: {component}")
+            return 1
+
+        if comp_info.installed:
+            self.print_success(f"{comp_info.name} is already installed!")
+            return 0
+
+        return self._install_components([component])
+
+    def install_all_components(self) -> int:
+        """Install all missing components."""
+        self.detector.refresh()
+        summary = self.detector.get_status_summary()
+
+        if not summary["missing"]:
+            self.print_success("All components are already installed!")
+            return 0
+
+        return self._install_components(summary["missing"])
+
+    def _install_components(self, components: List[str]) -> int:
+        """Install multiple components."""
+        self.print(f"\n📦 Installing {len(components)} component(s)...")
+
+        failed = []
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=self.console,
+        ) as progress:
+            for comp in components:
+                task = progress.add_task(f"Installing {comp}...", total=None)
+
+                install_cmd = self.detector.get_installation_command(comp)
+                if not install_cmd:
+                    progress.update(
+                        task,
+                        description=f"[red]Failed to get install command for {comp}",
+                    )
+                    failed.append(comp)
+                    continue
+
+                try:
+                    # Run pip install
+                    result = subprocess.run(
+                        [sys.executable, "-m", "pip", "install"]
+                        + install_cmd.split()[2:],
+                        capture_output=True,
+                        text=True,
+                        check=False,
+                    )
+
+                    if result.returncode == 0:
+                        progress.update(
+                            task, description=f"[green]✅ {comp} installed successfully"
+                        )
+                    else:
+                        progress.update(
+                            task, description=f"[red]❌ Failed to install {comp}"
+                        )
+                        failed.append(comp)
+                        if result.stderr:
+                            self.print_error(f"Error: {result.stderr}")
+
+                except Exception as e:
+                    progress.update(
+                        task, description=f"[red]❌ Error installing {comp}: {e}"
+                    )
+                    failed.append(comp)
+
+        # Show summary
+        if failed:
+            self.print_error(
+                f"\n❌ Failed to install {len(failed)} component(s): {', '.join(failed)}"
+            )
+            return 1
+        else:
+            self.print_success(
+                f"\n✅ Successfully installed {len(components)} component(s)!"
+            )
+            self.print("\n💡 Next steps:")
+            self.print("  • Configure the platform: manta config init --interactive")
+            self.print("  • View documentation: manta doc")
+            return 0
+
+    def _check_python_version(self) -> bool:
+        """Check Python version requirement."""
+        python_version = f"{sys.version_info.major}.{sys.version_info.minor}"
+        required_version = "3.9"
+
+        if sys.version_info.major == 3 and sys.version_info.minor >= 9:
+            self.print(f"✅ Python {python_version} (>= {required_version} required)")
+            return True
+        else:
+            self.print_error(
+                f"❌ Python {python_version} (>= {required_version} required)"
+            )
+            return False
+
+    def _check_pip(self) -> bool:
+        """Check if pip is available."""
+        try:
+            result = subprocess.run(
+                [sys.executable, "-m", "pip", "--version"],
+                capture_output=True,
+                text=True,
+                check=False,
+                timeout=5,
+            )
+            if result.returncode == 0:
+                pip_version = result.stdout.split()[1] if result.stdout else "Unknown"
+                self.print(f"✅ pip {pip_version}")
+                return True
+            else:
+                self.print_error("❌ pip is not available")
+                return False
+        except Exception:
+            self.print_error("❌ pip is not available")
+            return False
+
+    def _check_git(self) -> bool:
+        """Check if git is available."""
+        try:
+            result = subprocess.run(
+                ["git", "--version"],
+                capture_output=True,
+                text=True,
+                check=False,
+                timeout=5,
+            )
+            if result.returncode == 0:
+                git_version = result.stdout.strip()
+                self.print(f"✅ {git_version}")
+                return True
+            else:
+                self.print_warning("⚠️  Git is not available (optional)")
+                return True  # Git is optional
+        except Exception:
+            self.print_warning("⚠️  Git is not available (optional)")
+            return True  # Git is optional
+
+    def _check_docker(self) -> bool:
+        """Check if Docker is available."""
+        try:
+            result = subprocess.run(
+                ["docker", "--version"],
+                capture_output=True,
+                text=True,
+                check=False,
+                timeout=5,
+            )
+            if result.returncode == 0:
+                docker_version = result.stdout.strip()
+                self.print(f"✅ {docker_version} (optional)")
+                return True
+            else:
+                self.print_warning("⚠️  Docker is not available (optional)")
+                return True  # Docker is optional
+        except Exception:
+            self.print_warning("⚠️  Docker is not available (optional)")
+            return True  # Docker is optional

manta/cli/commands/sdk.py

@@ -0,0 +1,9 @@
+"""SDK Commands for Manta CLI.
+
+This module exports the main SDKCommands class that integrates
+with the unified Manta CLI system.
+"""
+
+from .sdk_main import SDKCommands
+
+__all__ = ["SDKCommands"]

manta/cli/commands/sdk_cluster.py

@@ -0,0 +1,211 @@
+"""SDK cluster information and management commands."""
+
+from rich.panel import Panel
+from rich.table import Table
+
+from .base_handler import BaseSDKHandler
+from ..utils import (
+    enum_to_string,
+    timestamp_to_string,
+    extract_platform_type,
+    NODE_STATUS_MAP,
+    CLUSTER_STATUS_MAP,
+)
+
+
+class SDKClusterHandler(BaseSDKHandler):
+    """Handle cluster-related SDK commands."""
+
+    def add_subparsers(self, parent_parser):
+        """Add cluster command subparsers."""
+        self.parser = parent_parser  # Store parser reference
+        subparsers = parent_parser.add_subparsers(
+            dest="cluster_command", help="Cluster commands"
+        )
+
+        # List clusters command
+        list_parser = subparsers.add_parser("list", help="List available clusters")
+
+        # Show cluster command
+        show_parser = subparsers.add_parser(
+            "show", help="Show detailed cluster information"
+        )
+        show_parser.add_argument("cluster_id", help="Cluster ID to show")
+
+        # Get cluster nodes command
+        nodes_parser = subparsers.add_parser("nodes", help="List nodes in cluster")
+        nodes_parser.add_argument("cluster_id", help="Cluster ID to show nodes for")
+
+        # Add common arguments to all subcommands
+        for parser in [list_parser, show_parser, nodes_parser]:
+            parser.add_argument("--profile", help="Use specific profile")
+            parser.add_argument(
+                "--debug", action="store_true", help="Enable debug output"
+            )
+
+    def handle(self, args) -> int:
+        """Handle cluster commands."""
+        # Enable debug if requested
+        if getattr(args, "debug", False):
+            self.enable_debug(True)
+
+        if not args.cluster_command:
+            if hasattr(self, "parser"):
+                self.parser.print_help()
+            return 0  # Return 0 for help display
+
+        if args.cluster_command == "list":
+            return self.list_clusters()
+        elif args.cluster_command == "show":
+            return self.show_cluster(args.cluster_id)
+        elif args.cluster_command == "nodes":
+            return self.show_cluster_nodes(args.cluster_id)
+        else:
+            self.print_error(f"Unknown cluster command: {args.cluster_command}")
+            return 1
+
+    def list_clusters(self) -> int:
+        """List available clusters."""
+        api = self._get_user_api()
+        if not api:
+            return 1
+
+        try:
+
+            async def run():
+                clusters = await api.stream_and_fetch_clusters()
+                return clusters
+
+            clusters = self._run_with_progress(run, "Fetching clusters...")
+
+            # Check if the operation failed
+            if clusters is None:
+                return 1
+
+            # Display clusters
+            if not clusters:
+                self.print("No clusters found.")
+                return 0
+
+            # Always use console (it's always available in SDK context)
+            table = Table(title="Available Clusters")
+            table.add_column("Cluster ID", style="cyan")
+            table.add_column("Name", style="blue")
+            table.add_column("Status", style="green")
+            table.add_column("Nodes", style="magenta")
+
+            for cluster in clusters:
+                status = enum_to_string(cluster.get("status", 0), CLUSTER_STATUS_MAP)
+
+                table.add_row(
+                    cluster.get("cluster_id", "Unknown"),
+                    cluster.get("name", "Unknown"),
+                    status,
+                    str(cluster.get("node_count", 0)),
+                )
+
+            self.console.print(table)
+
+            return 0
+
+        except KeyboardInterrupt:
+            return 130  # Standard exit code for SIGINT
+        except Exception:
+            # Error already printed by base handler
+            return 1
+
+    def show_cluster(self, cluster_id: str) -> int:
+        """Show detailed cluster information."""
+        api = self._get_user_api()
+        if not api:
+            return 1
+
+        try:
+
+            async def run():
+                return await api.get_cluster(cluster_id)
+
+            cluster = self._run_with_progress(run, f"Fetching cluster {cluster_id}...")
+
+            # Check if the operation failed
+            if cluster is None:
+                return 1
+
+            # Extract and format fields
+            status = enum_to_string(cluster.get("status", 0), CLUSTER_STATUS_MAP)
+            created = timestamp_to_string(
+                cluster.get("created_at") or cluster.get("creation_date")
+            )
+
+            # Display cluster details
+            panel = Panel.fit(
+                f"[cyan]Cluster ID:[/cyan] {cluster.get('cluster_id', 'Unknown')}\n"
+                f"[cyan]Name:[/cyan] {cluster.get('name', 'Unknown')}\n"
+                f"[cyan]Status:[/cyan] {status}\n"
+                f"[cyan]Node Count:[/cyan] {cluster.get('node_count', 0)}\n"
+                f"[cyan]Created:[/cyan] {created}",
+                title=f"Cluster: {cluster_id}",
+            )
+            self.console.print(panel)
+
+            return 0
+
+        except KeyboardInterrupt:
+            return 130
+        except Exception:
+            # Error already printed by base handler
+            return 1
+
+    def show_cluster_nodes(self, cluster_id: str) -> int:
+        """Show nodes in a cluster."""
+        api = self._get_user_api()
+        if not api:
+            return 1
+
+        try:
+
+            async def run():
+                return await api.stream_and_fetch_nodes(cluster_id)
+
+            nodes = self._run_with_progress(
+                run, f"Fetching nodes for cluster {cluster_id}..."
+            )
+
+            # Check if the operation failed
+            if nodes is None:
+                return 1
+
+            if not nodes:
+                self.print("No nodes found in this cluster.")
+                return 0
+
+            # Create and display nodes table
+            table = Table(title=f"Nodes in Cluster: {cluster_id}")
+            table.add_column("Node ID", style="cyan")
+            table.add_column("Status", style="green")
+            table.add_column("Type", style="blue")
+            table.add_column("Last Seen", style="yellow")
+
+            for node in nodes:
+                # Use converter functions for consistent parsing
+                status = enum_to_string(node.get("node_status", 0), NODE_STATUS_MAP)
+
+                node_type = extract_platform_type(node.get("platform_info"))
+
+                last_seen = timestamp_to_string(
+                    node.get("updated_at") or node.get("created_at")
+                )
+
+                table.add_row(
+                    node.get("node_id", "Unknown"), status, node_type, last_seen
+                )
+
+            self.console.print(table)
+
+            return 0
+
+        except KeyboardInterrupt:
+            return 130
+        except Exception:
+            # Error already printed by base handler
+            return 1