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

manta/cli/config_manager.py

@@ -0,0 +1,445 @@
+"""Simplified SDK Configuration Manager for manta-sdk.
+
+This module provides simple configuration management for SDK operations,
+using individual config files in ~/.manta/sdk/ directory with an active config system.
+Matches the pattern used by manta-node config management.
+"""
+
+import threading
+from dataclasses import asdict, dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+try:
+    import tomllib  # Python 3.11+
+except ImportError:
+    import tomli as tomllib  # Python < 3.11 fallback
+
+import toml  # For writing TOML files
+
+__all__ = ["SDKConfigManager", "SDKConfiguration"]
+
+
+@dataclass
+class SDKConfiguration:
+    """Simple SDK configuration matching AsyncUserAPI parameters."""
+
+    # Core AsyncUserAPI parameters (token is required)
+    token: str
+    host: str = "localhost"
+    port: int = 50052
+    cert_folder: Optional[str] = None
+
+    # Configuration metadata
+    name: str = "default"
+    description: str = "SDK configuration"
+    created_at: str = field(default_factory=lambda: datetime.now().isoformat())
+    updated_at: str = field(default_factory=lambda: datetime.now().isoformat())
+
+    def __post_init__(self):
+        """Validate configuration after initialization."""
+        if not self.token or self.token.strip() == "":
+            raise ValueError("token is required and cannot be empty")
+
+        if not self.host or self.host.strip() == "":
+            raise ValueError("host is required and cannot be empty")
+
+        if self.port <= 0 or self.port > 65535:
+            raise ValueError("port must be a valid port number (1-65535)")
+
+
+class SDKConfigManager:
+    """Simple configuration manager for SDK matching node config pattern."""
+
+    DEFAULT_CONFIG_DIR = Path.home() / ".manta" / "sdk"
+    ACTIVE_CONFIG_FILE = DEFAULT_CONFIG_DIR / "active"
+
+    def __init__(self, config_dir: Optional[Path] = None):
+        """Initialize SDK configuration manager.
+
+        Args:
+            config_dir: Optional custom configuration directory
+        """
+        self.config_dir = Path(config_dir) if config_dir else self.DEFAULT_CONFIG_DIR
+        self.active_config_file = self.config_dir / "active"
+        self._lock = threading.RLock()
+
+        # Ensure config directory exists
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+
+    def _ensure_config_dir(self):
+        """Ensure the configuration directory exists."""
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+
+    def list_configs(self) -> List[str]:
+        """List all available configuration names.
+
+        Returns:
+            List of configuration names (without .toml extension)
+        """
+        self._ensure_config_dir()
+        configs = []
+
+        for config_file in self.config_dir.glob("*.toml"):
+            configs.append(config_file.stem)
+
+        return sorted(configs)
+
+    def config_exists(self, config_name: str) -> bool:
+        """Check if a configuration exists.
+
+        Args:
+            config_name: Name of the configuration
+
+        Returns:
+            True if configuration exists
+        """
+        config_path = self.config_dir / f"{config_name}.toml"
+        return config_path.exists()
+
+    def save_config(
+        self, config: SDKConfiguration, config_name: Optional[str] = None
+    ) -> bool:
+        """Save a configuration to file.
+
+        Args:
+            config: Configuration to save
+            config_name: Name for the configuration (uses config.name if None)
+
+        Returns:
+            True if saved successfully
+        """
+        if config_name is None:
+            config_name = config.name
+
+        config_path = self.config_dir / f"{config_name}.toml"
+
+        with self._lock:
+            try:
+                self._ensure_config_dir()
+
+                # Update timestamps
+                config.name = config_name
+                config.updated_at = datetime.now().isoformat()
+
+                # Convert to dictionary and save
+                config_dict = asdict(config)
+
+                with open(config_path, "w") as f:
+                    toml.dump(config_dict, f)
+
+                return True
+
+            except Exception as e:
+                print(f"Error saving configuration: {e}")
+                return False
+
+    def load_config(self, config_name: str) -> Optional[SDKConfiguration]:
+        """Load a configuration from file.
+
+        Args:
+            config_name: Name of the configuration to load
+
+        Returns:
+            Configuration object or None if not found/invalid
+        """
+        config_path = self.config_dir / f"{config_name}.toml"
+
+        if not config_path.exists():
+            return None
+
+        try:
+            with open(config_path, "rb") as f:
+                data = tomllib.load(f)
+
+            # Create configuration object
+            return SDKConfiguration(**data)
+
+        except Exception as e:
+            print(f"Error loading configuration '{config_name}': {e}")
+            return None
+
+    def delete_config(self, config_name: str) -> bool:
+        """Delete a configuration.
+
+        Args:
+            config_name: Name of the configuration to delete
+
+        Returns:
+            True if deleted successfully
+        """
+        if config_name == "default":
+            print("Cannot delete the default configuration")
+            return False
+
+        config_path = self.config_dir / f"{config_name}.toml"
+
+        with self._lock:
+            try:
+                if config_path.exists():
+                    config_path.unlink()
+
+                # If deleted config was active, switch to default
+                active_config = self.get_active_config_name()
+                if active_config == config_name:
+                    self.set_active_config("default")
+
+                return True
+
+            except Exception as e:
+                print(f"Error deleting configuration: {e}")
+                return False
+
+    def get_active_config_name(self) -> str:
+        """Get the name of the active configuration.
+
+        Returns:
+            Name of active configuration (defaults to 'default')
+        """
+        if self.active_config_file.exists():
+            try:
+                return self.active_config_file.read_text().strip()
+            except Exception:
+                pass
+
+        return "default"
+
+    def set_active_config(self, config_name: str) -> bool:
+        """Set the active configuration.
+
+        Args:
+            config_name: Name of the configuration to make active
+
+        Returns:
+            True if set successfully
+        """
+        # Check if config exists
+        if not self.config_exists(config_name):
+            print(f"Configuration '{config_name}' not found")
+            return False
+
+        with self._lock:
+            try:
+                self._ensure_config_dir()
+                self.active_config_file.write_text(config_name)
+                return True
+
+            except Exception as e:
+                print(f"Error setting active configuration: {e}")
+                return False
+
+    def get_active_config(self) -> Optional[SDKConfiguration]:
+        """Get the active configuration.
+
+        Returns:
+            Active configuration or None if not found
+        """
+        active_name = self.get_active_config_name()
+        return self.load_config(active_name)
+
+    def create_default_config(self) -> bool:
+        """Create a default configuration if it doesn't exist.
+
+        Returns:
+            True if created successfully
+        """
+        if self.config_exists("default"):
+            return True
+
+        # Create minimal default config (user must provide token)
+        try:
+            default_config = SDKConfiguration(
+                name="default",
+                token="<REQUIRED_JWT_TOKEN>",  # Placeholder that will trigger validation error
+                host="localhost",
+                port=50052,
+                description="Default SDK configuration - please set your JWT token",
+            )
+        except ValueError:
+            # Create with bypass for initial creation
+            default_config = SDKConfiguration.__new__(SDKConfiguration)
+            default_config.name = "default"
+            default_config.token = "<REQUIRED_JWT_TOKEN>"
+            default_config.host = "localhost"
+            default_config.port = 50052
+            default_config.cert_folder = None
+            default_config.description = (
+                "Default SDK configuration - please set your JWT token"
+            )
+            default_config.created_at = datetime.now().isoformat()
+            default_config.updated_at = datetime.now().isoformat()
+
+        success = self.save_config(default_config, "default")
+        if success:
+            self.set_active_config("default")
+
+        return success
+
+    def create_config(
+        self,
+        name: str,
+        token: str,
+        host: str = "localhost",
+        port: int = 50052,
+        cert_folder: Optional[str] = None,
+        description: Optional[str] = None,
+    ) -> bool:
+        """Create a new configuration.
+
+        Args:
+            name: Configuration name
+            token: JWT authentication token
+            host: Server host
+            port: Server port
+            cert_folder: Path to certificate folder
+            description: Configuration description
+
+        Returns:
+            True if configuration created successfully
+        """
+        if self.config_exists(name):
+            print(f"Configuration '{name}' already exists")
+            return False
+
+        try:
+            config = SDKConfiguration(
+                name=name,
+                token=token,
+                host=host,
+                port=port,
+                cert_folder=cert_folder,
+                description=description or f"SDK configuration '{name}'",
+            )
+
+            return self.save_config(config, name)
+
+        except ValueError as e:
+            print(f"Invalid configuration: {e}")
+            return False
+
+    def update_config(self, name: str, **kwargs) -> bool:
+        """Update an existing configuration.
+
+        Args:
+            name: Configuration name
+            **kwargs: Fields to update
+
+        Returns:
+            True if configuration updated successfully
+        """
+        config = self.load_config(name)
+        if not config:
+            print(f"Configuration '{name}' not found")
+            return False
+
+        # Update fields
+        if "token" in kwargs:
+            config.token = kwargs["token"]
+        if "host" in kwargs:
+            config.host = kwargs["host"]
+        if "port" in kwargs:
+            config.port = kwargs["port"]
+        if "cert_folder" in kwargs:
+            config.cert_folder = kwargs["cert_folder"]
+        if "description" in kwargs:
+            config.description = kwargs["description"]
+
+        config.updated_at = datetime.now().isoformat()
+
+        try:
+            # Validate updated configuration
+            config.__post_init__()
+            return self.save_config(config, name)
+        except ValueError as e:
+            print(f"Invalid configuration update: {e}")
+            return False
+
+    # delete_config method already implemented above
+
+    # set_active_config method already implemented above
+
+    # list_configs method already implemented above
+
+    def get_config(self, name: Optional[str] = None) -> Optional[SDKConfiguration]:
+        """Get a specific configuration or the active one.
+
+        Args:
+            name: Configuration name (uses active if None)
+
+        Returns:
+            Configuration object or None if not found
+        """
+        if name is None:
+            return self.get_active_config()
+        return self.load_config(name)
+
+    # get_active_config method already implemented above
+
+    def get_connection_params(
+        self, config_name: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Get connection parameters for AsyncUserAPI initialization.
+
+        Args:
+            config_name: Configuration name (uses active if None)
+
+        Returns:
+            Dictionary with connection parameters for AsyncUserAPI
+        """
+        config = self.get_config(config_name)
+        if not config:
+            return {}
+
+        # Return parameters matching AsyncUserAPI constructor
+        params = {
+            "token": config.token,
+            "host": config.host,
+            "port": config.port,
+            "cert_folder": config.cert_folder,
+        }
+
+        return params
+
+    def validate_config(self, config: SDKConfiguration) -> List[str]:
+        """Validate a configuration and return any errors.
+
+        Args:
+            config: Configuration to validate
+
+        Returns:
+            List of validation error messages (empty if valid)
+        """
+        errors = []
+
+        # Token validation
+        if not config.token or config.token.strip() == "":
+            errors.append("Token is required")
+        elif config.token.startswith("<") and config.token.endswith(">"):
+            errors.append(
+                "Please replace the placeholder token with your actual JWT token"
+            )
+        elif len(config.token) < 10:
+            errors.append("Token appears to be too short for a valid JWT token")
+
+        # Host validation
+        if not config.host or config.host.strip() == "":
+            errors.append("Host is required")
+
+        # Port validation
+        if config.port <= 0 or config.port > 65535:
+            errors.append("Port must be a valid port number (1-65535)")
+
+        # Certificate folder validation (if provided)
+        if config.cert_folder:
+            cert_path = Path(config.cert_folder).expanduser()
+            if not cert_path.exists():
+                errors.append(
+                    f"Certificate folder does not exist: {config.cert_folder}"
+                )
+            elif not cert_path.is_dir():
+                errors.append(
+                    f"Certificate folder is not a directory: {config.cert_folder}"
+                )
+
+        return errors

manta/cli/main.py

@@ -0,0 +1,265 @@
+"""Main unified Manta CLI entry point.
+
+This module provides the main CLI interface that works across all Manta components
+with dynamic component detection and installation assistance.
+"""
+
+import argparse
+import logging
+import sys
+
+from rich.console import Console
+
+from .commands.doc import DocCommands
+from .commands.install import InstallCommands
+from .commands.status import StatusCommands
+from .component_detector import ComponentDetector
+
+logger = logging.getLogger(__name__)
+
+
+class MantaCLI:
+    """Main unified CLI application."""
+
+    def __init__(self):
+        self.console = Console()
+        self.detector = ComponentDetector()
+
+        # Base commands always available
+        self.install_cmd = InstallCommands(self.detector, self.console)
+        self.status_cmd = StatusCommands(self.detector, self.console)
+        self.doc_cmd = DocCommands(self.console)
+
+        # Component commands (loaded dynamically)
+        self.sdk_cmd = None
+        self.admin_main = None
+        self.node_main = None
+
+        # Try to load component commands
+        self._load_component_commands()
+
+    def _load_component_commands(self):
+        """Load component commands - SDK is always available, others detected."""
+        # SDK commands are always available since we're part of manta-sdk
+        try:
+            from manta.cli.commands.sdk import SDKCommands
+
+            self.sdk_cmd = SDKCommands(self.console)
+        except ImportError:
+            # This should never happen since we're in manta-sdk
+            self.sdk_cmd = None
+
+        # Try to get admin main function for direct delegation
+        try:
+            from manta_admin.cli.main import main as admin_main
+
+            self.admin_main = admin_main
+        except ImportError:
+            self.admin_main = None
+
+        # Try to get node main function for direct delegation
+        try:
+            from manta_node.cli.main import main as node_main
+
+            self.node_main = node_main
+        except ImportError:
+            self.node_main = None
+
+    def print(self, *args, **kwargs):
+        """Rich print function."""
+        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_missing_component(self, component: str, command: str):
+        """Handle missing component error with installation guidance."""
+        comp_info = self.detector.get_component_info(component)
+
+        if comp_info:
+            self.print_error(
+                f"Command '{command}' requires {comp_info.name} but it's not installed."
+            )
+            self.print(f"\nTo install {comp_info.name}:")
+
+            # Suggest installation command
+            install_cmd = self.detector.get_installation_command(component)
+            self.print(f"  {install_cmd}")
+
+            self.print("\nAlternatively, use the installation wizard:")
+            self.print("  manta install wizard")
+        else:
+            self.print_error(f"Unknown component: {component}")
+
+
+def create_parser(cli: MantaCLI) -> argparse.ArgumentParser:
+    """Create main argument parser with dynamic subcommands."""
+    parser = argparse.ArgumentParser(
+        prog="manta",
+        description="Unified Manta CLI - Manage SDK, Node, and Admin operations",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  manta status                  # Show component status
+  manta install wizard          # Interactive installation
+  manta doc                     # View documentation
+
+Component Commands (when installed):
+  manta sdk <command>           # SDK operations (user, cluster, swarm, results)
+  manta node <command>          # Node operations (start, stop, config, logs)
+""",
+    )
+
+    parser.add_argument("--version", action="version", version="%(prog)s 0.5b0")
+
+    parser.add_argument("--debug", action="store_true", help="Enable debug output")
+
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # Status command (always available)
+    status_parser = subparsers.add_parser("status", help="Show Manta platform status")
+    status_parser.add_argument(
+        "status_command",
+        nargs="?",
+        choices=["installation", "system", "services"],
+        help="Specific status to show",
+    )
+
+    # Install command (always available)
+    install_parser = subparsers.add_parser("install", help="Install Manta components")
+    install_parser.add_argument(
+        "install_command",
+        nargs="?",
+        choices=["wizard", "check", "sdk", "admin", "node", "all"],
+        help="Installation command",
+    )
+
+    # Documentation command (always available)
+    doc_parser = subparsers.add_parser("doc", help="View Manta documentation")
+    doc_parser.add_argument(
+        "doc_topic",
+        nargs="?",
+        choices=[
+            "main",
+            "sdk",
+            "admin",
+            "node",
+            "api",
+            "examples",
+            "quickstart",
+            "architecture",
+            "configuration",
+            "deployment",
+        ],
+        help="Documentation topic to view",
+    )
+    doc_parser.add_argument(
+        "--open", action="store_true", help="Open documentation in browser"
+    )
+
+    # SDK commands (always available since we're part of manta-sdk)
+    if cli.sdk_cmd:
+        sdk_parser = subparsers.add_parser(
+            "sdk", help="SDK operations (user, swarm, module, cluster, results, config)"
+        )
+        sdk_subparsers = sdk_parser.add_subparsers(
+            dest="sdk_command", help="SDK commands"
+        )
+
+        # Add SDK subcommands (including config)
+        cli.sdk_cmd.add_subparsers(sdk_subparsers)
+
+    # Node commands (if installed) - simplified delegation
+    if cli.node_main:
+        node_parser = subparsers.add_parser(
+            "node", help="Node operations (start, stop, status, cluster)"
+        )
+        node_parser.add_argument(
+            "node_args",
+            nargs=argparse.REMAINDER,
+            help="Node command arguments (will be passed to manta-node CLI)",
+        )
+
+    return parser
+
+
+def main():
+    """Main entry point for the Manta CLI."""
+    # Create CLI instance
+    cli = MantaCLI()
+
+    # Create parser
+    parser = create_parser(cli)
+
+    # Parse arguments
+    args = parser.parse_args()
+
+    # Configure logging
+    if args.debug:
+        logging.basicConfig(level=logging.DEBUG)
+    else:
+        logging.basicConfig(level=logging.WARNING)
+
+    # Handle commands
+    try:
+        if not args.command:
+            parser.print_help()
+            return 0
+
+        # Base commands (always available)
+        if args.command == "status":
+            return cli.status_cmd.handle(args)
+        elif args.command == "install":
+            return cli.install_cmd.handle(args)
+        elif args.command == "doc":
+            return cli.doc_cmd.handle(args)
+
+        # Component commands (check if installed)
+        elif args.command == "sdk":
+            if cli.sdk_cmd:
+                return cli.sdk_cmd.handle(args)
+            else:
+                cli.handle_missing_component("sdk", "manta sdk")
+                return 1
+
+        elif args.command == "node":
+            if cli.node_main:
+                # Direct delegation to manta-node CLI
+                node_args = getattr(args, "node_args", [])
+                try:
+                    return cli.node_main(node_args)
+                except Exception as e:
+                    cli.print_error(f"Error executing node command: {e}")
+                    return 1
+            else:
+                cli.handle_missing_component("node", "manta node")
+                return 1
+
+        else:
+            cli.print_error(f"Unknown command: {args.command}")
+            parser.print_help()
+            return 1
+
+    except KeyboardInterrupt:
+        cli.print("\n\nInterrupted by user")
+        return 130
+    except Exception as e:
+        cli.print_error(f"An error occurred: {e}")
+        if args.debug:
+            import traceback
+
+            traceback.print_exc()
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())