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

manta/cli/commands/sdk_logs.py

@@ -0,0 +1,174 @@
+"""SDK log retrieval and streaming commands."""
+
+import signal
+import time
+from typing import Optional
+
+from rich.table import Table
+
+from .base_handler import BaseSDKHandler
+from ..utils.converters import enum_to_string, LOG_SEVERITY_MAP
+
+
+class SDKLogsHandler(BaseSDKHandler):
+    """Handle log-related SDK commands."""
+
+    def add_subparsers(self, parent_parser):
+        """Add logs command subparsers."""
+        self.parser = parent_parser  # Store parser reference
+        subparsers = parent_parser.add_subparsers(
+            dest="logs_command", help="Log commands"
+        )
+
+        # Get logs command
+        get_parser = subparsers.add_parser("get", help="Get logs for a swarm or task")
+        get_parser.add_argument("target_id", help="Swarm ID or Task ID to get logs for")
+        get_parser.add_argument(
+            "--type",
+            choices=["swarm", "task"],
+            default="swarm",
+            help="Type of target (default: swarm)",
+        )
+        get_parser.add_argument("--lines", type=int, help="Number of lines to retrieve")
+
+        # Stream logs command
+        stream_parser = subparsers.add_parser("stream", help="Stream logs in real-time")
+        stream_parser.add_argument(
+            "target_id", help="Swarm ID or Task ID to stream logs for"
+        )
+        stream_parser.add_argument(
+            "--type",
+            choices=["swarm", "task"],
+            default="swarm",
+            help="Type of target (default: swarm)",
+        )
+
+        # Add profile override to all subcommands
+        for parser in [get_parser, stream_parser]:
+            parser.add_argument("--profile", help="Use specific profile")
+
+    def handle(self, args) -> int:
+        """Handle logs commands."""
+        if not args.logs_command:
+            if hasattr(self, "parser"):
+                self.parser.print_help()
+            return 0  # Return 0 for help display
+
+        if args.logs_command == "get":
+            return self.get_logs(
+                args.target_id,
+                getattr(args, "type", "swarm"),
+                getattr(args, "lines", None),
+            )
+        elif args.logs_command == "stream":
+            return self.stream_logs(args.target_id, getattr(args, "type", "swarm"))
+        else:
+            self.print_error(f"Unknown logs command: {args.logs_command}")
+            return 1
+
+    def get_logs(
+        self, target_id: str, log_type: str = "swarm", lines: Optional[int] = None
+    ) -> int:
+        """Get logs for a swarm or task."""
+        api = self._get_user_api()
+        if not api:
+            return 1
+
+        try:
+
+            async def run():
+                if log_type == "swarm":
+                    return await api.get_swarm_logs(target_id, lines=lines)
+                else:
+                    return await api.get_task_logs(target_id, lines=lines)
+
+            logs = self._run_with_progress(
+                run, f"Fetching logs for {log_type} {target_id}..."
+            )
+
+            if logs is None:
+                return 1
+
+            if not logs:
+                self.print("No logs found.")
+                return 0
+
+            # Display logs
+            table = Table(title=f"Logs for {log_type.title()}: {target_id}")
+            table.add_column("Timestamp", style="cyan")
+            table.add_column("Level", style="blue")
+            table.add_column("Message", style="white")
+
+            for log_entry in logs:
+                # Convert log level if it's an enum
+                level = log_entry.get("level", "INFO")
+                if isinstance(level, int):
+                    level = enum_to_string(level, LOG_SEVERITY_MAP)
+
+                table.add_row(
+                    log_entry.get("timestamp", "Unknown"),
+                    level,
+                    log_entry.get("message", ""),
+                )
+
+            self.console.print(table)
+
+            return 0
+
+        except Exception as e:
+            self.print_error(f"Failed to get logs: {e}")
+            return 1
+
+    def stream_logs(self, target_id: str, log_type: str = "swarm") -> int:
+        """Stream logs in real-time."""
+        api = self._get_user_api()
+        if not api:
+            return 1
+
+        self.print(f"Streaming logs for {log_type}: {target_id}")
+        self.print("Press Ctrl+C to stop streaming...")
+
+        try:
+            # Set up signal handler for graceful shutdown
+            shutdown_flag = False
+
+            def signal_handler(sig, frame):
+                nonlocal shutdown_flag
+                shutdown_flag = True
+
+            signal.signal(signal.SIGINT, signal_handler)
+
+            last_log_count = 0
+
+            while not shutdown_flag:
+                try:
+
+                    async def get_logs():
+                        if log_type == "swarm":
+                            return await api.get_swarm_logs(target_id)
+                        else:
+                            return await api.get_task_logs(target_id)
+
+                    logs = self._run_async(get_logs())
+
+                    # Show new logs since last check
+                    if logs and len(logs) > last_log_count:
+                        new_logs = logs[last_log_count:]
+
+                        for log_entry in new_logs:
+                            timestamp = log_entry.get("timestamp", "unknown")
+                            level = log_entry.get("level", "INFO")
+                            message = log_entry.get("message", "")
+                            self.print(f"[{timestamp}] {level}: {message}")
+
+                        last_log_count = len(logs)
+
+                    time.sleep(2)  # Poll every 2 seconds for logs
+
+                except KeyboardInterrupt:
+                    self.print("\nLog streaming stopped.")
+                    return 130  # KeyboardInterrupt exit code
+
+        except Exception as e:
+            self.print_error(f"Log streaming failed: {e}")
+            return 1

manta/cli/commands/sdk_main.py

@@ -0,0 +1,167 @@
+"""Main SDK commands class that delegates to modular command handlers."""
+
+from typing import Optional
+
+from rich.console import Console
+
+from ..config_manager import SDKConfigManager
+
+# User commands removed - unified into config commands
+from .sdk_module import SDKModuleHandler
+from .sdk_swarm import SDKSwarmHandler
+from .sdk_cluster import SDKClusterHandler
+from .sdk_results import SDKResultsHandler
+from .sdk_globals import SDKGlobalsHandler
+
+# Removed SDKNodesHandler - node operations should use 'manta node' commands
+from .sdk_logs import SDKLogsHandler
+from .sdk_config import SDKConfigHandler
+
+
+class SDKCommands:
+    """Main SDK commands class that delegates to modular handlers."""
+
+    def __init__(self, console: Optional[Console] = None):
+        """Initialize with optional console (for backwards compatibility with CLI)."""
+        self.console = console or Console()
+
+        # Initialize config manager - will be properly instantiated when needed
+        self.config_manager = None
+
+        # Initialize handlers - will be created lazily
+        self._handlers = {}
+
+    def _ensure_managers(self):
+        """Ensure config manager is initialized."""
+        if self.config_manager is None:
+            self.config_manager = SDKConfigManager()
+
+    def _get_handler(self, handler_name: str):
+        """Get or create a command handler."""
+        if handler_name not in self._handlers:
+            self._ensure_managers()
+
+            handler_classes = {
+                # 'user' removed - unified into config
+                "module": SDKModuleHandler,
+                "swarm": SDKSwarmHandler,
+                "cluster": SDKClusterHandler,
+                "results": SDKResultsHandler,
+                "globals": SDKGlobalsHandler,
+                "logs": SDKLogsHandler,
+                "config": SDKConfigHandler,
+            }
+
+            if handler_name not in handler_classes:
+                raise ValueError(f"Unknown handler: {handler_name}")
+
+            handler_class = handler_classes[handler_name]
+            self._handlers[handler_name] = handler_class(
+                self.console, self.config_manager
+            )
+
+        return self._handlers[handler_name]
+
+    def handle(self, args) -> int:
+        """Handle SDK commands by delegating to appropriate handlers."""
+        # Extract the primary command
+        if hasattr(args, "sdk_command"):
+            command = args.sdk_command
+        else:
+            # Fallback for direct usage
+            command = getattr(args, "command", None)
+
+        if not command:
+            self.console.print("[red]Error:[/red] No command specified")
+            return 1
+
+        # Set config override if specified
+        config_override = getattr(args, "config", None)
+
+        # Map commands to handlers
+        command_mapping = {
+            # 'user' removed - unified into config
+            "cluster": "cluster",
+            "module": "module",
+            "swarm": "swarm",
+            "results": "results",
+            "globals": "globals",
+            "logs": "logs",
+            "config": "config",
+        }
+
+        handler_name = command_mapping.get(command)
+        if not handler_name:
+            self.console.print(f"[red]Error:[/red] Unknown SDK command: {command}")
+            return 1
+
+        try:
+            handler = self._get_handler(handler_name)
+
+            # Set config override if specified
+            if config_override:
+                handler.set_profile_override(config_override)
+
+            return handler.handle(args)
+
+        except Exception as e:
+            self.console.print(f"[red]Error:[/red] Failed to execute command: {e}")
+            return 1
+
+    def add_subparsers(self, parent_parser):
+        """Add all SDK subcommands to the parent parser."""
+        # Ensure managers are initialized for handler creation
+        self._ensure_managers()
+
+        # User commands removed - unified into config
+
+        # Module commands
+        module_parser = parent_parser.add_parser(
+            "module", help="Module management operations"
+        )
+        module_handler = self._get_handler("module")
+        module_handler.add_subparsers(module_parser)
+
+        # Swarm commands
+        swarm_parser = parent_parser.add_parser(
+            "swarm", help="Swarm deployment and management"
+        )
+        swarm_handler = self._get_handler("swarm")
+        swarm_handler.add_subparsers(swarm_parser)
+
+        # Cluster commands
+        cluster_parser = parent_parser.add_parser(
+            "cluster", help="Cluster information and management"
+        )
+        cluster_handler = self._get_handler("cluster")
+        cluster_handler.add_subparsers(cluster_parser)
+
+        # Results commands
+        results_parser = parent_parser.add_parser(
+            "results", help="Results retrieval and management"
+        )
+        results_handler = self._get_handler("results")
+        results_handler.add_subparsers(results_parser)
+
+        # Globals commands
+        globals_parser = parent_parser.add_parser(
+            "globals", help="Globals retrieval and management"
+        )
+        globals_handler = self._get_handler("globals")
+        globals_handler.add_subparsers(globals_parser)
+
+        # Node commands removed - use 'manta node' instead
+
+        # Logs commands
+        logs_parser = parent_parser.add_parser(
+            "logs", help="Log retrieval and streaming"
+        )
+        logs_handler = self._get_handler("logs")
+        logs_handler.add_subparsers(logs_parser)
+
+        # Config commands
+        config_parser = parent_parser.add_parser(
+            "config", help="Configuration management"
+        )
+        config_handler = self._get_handler("config")
+        config_handler.add_subparsers(config_parser)