manta-node 0.5b0__py3-none-any.whl

manta_node/cli/commands/stop.py

@@ -0,0 +1,253 @@
+"""Node stop command implementation."""
+
+import argparse
+import json
+import os
+import signal
+import time
+from pathlib import Path
+from typing import List
+
+from rich.console import Console
+
+console = Console()
+
+
+def print_error(message: str):
+    """Print error message in red."""
+    console.print(f"[red]Error: {message}[/red]")
+
+
+def print_success(message: str):
+    """Print success message in green."""
+    console.print(f"[green]{message}[/green]")
+
+
+def print_warning(message: str):
+    """Print warning message in yellow."""
+    console.print(f"[yellow]{message}[/yellow]")
+
+
+def find_running_instances():
+    """Find running node instances by looking for instance JSON files."""
+
+    instances_dir = Path.home() / ".manta" / "nodes" / "instances"
+    instances = []
+
+    if not instances_dir.exists():
+        return instances
+
+    for instance_file in instances_dir.glob("*.json"):
+        try:
+            with open(instance_file, "r") as f:
+                instance_data = json.load(f)
+
+            pid = instance_data.get("pid")
+            instance_id = instance_data.get("instance_id", instance_file.stem)
+            alias = instance_data.get("alias", instance_id)
+
+            # Check if process is still running
+            try:
+                # Send signal 0 to check if process exists
+
+                os.kill(pid, 0)
+                instances.append(
+                    {
+                        "instance_id": instance_id,
+                        "alias": alias,
+                        "pid": pid,
+                        "instance_file": instance_file,
+                    }
+                )
+            except OSError:
+                # Process no longer exists, remove stale instance file
+                instance_file.unlink(missing_ok=True)
+
+        except (ValueError, FileNotFoundError):
+            # Invalid instance file, remove it
+            instance_file.unlink(missing_ok=True)
+
+    return instances
+
+
+def stop_instance_by_pid(
+    instance: dict, force: bool = False, timeout: int = 10
+) -> bool:
+    """Stop a node instance using its PID.
+
+    Args:
+        instance: Instance information dictionary
+        force: If True, use SIGKILL instead of SIGTERM
+        timeout: Seconds to wait for graceful shutdown before force killing
+
+    Returns:
+        True if successfully stopped, False otherwise
+    """
+    pid = instance["pid"]
+    instance_id = instance["instance_id"]
+    alias = instance.get("alias", instance_id)
+
+    try:
+        if force:
+            # Force kill with SIGKILL
+            os.kill(pid, signal.SIGKILL)
+            console.print(f"Force killed node '{alias}' (PID: {pid})")
+        else:
+            # Graceful shutdown with SIGTERM
+            os.kill(pid, signal.SIGTERM)
+            console.print(f"Sent termination signal to node '{alias}' (PID: {pid})")
+
+            # Wait for process to terminate gracefully
+            console.print(
+                f"[dim]Waiting up to {timeout} seconds for graceful shutdown...[/dim]"
+            )
+            start_time = time.time()
+            while time.time() - start_time < timeout:
+                try:
+                    # Check if process is still running
+                    os.kill(pid, 0)
+                    time.sleep(0.5)
+                except OSError:
+                    # Process has terminated
+                    console.print(f"[green]Node '{alias}' stopped gracefully[/green]")
+                    break
+            else:
+                # Timeout reached, process still running
+                print_warning(
+                    f"Node '{alias}' did not stop gracefully, sending SIGKILL..."
+                )
+                os.kill(pid, signal.SIGKILL)
+                console.print(f"Force killed node '{alias}' after timeout")
+
+        # Remove instance file
+        instance["instance_file"].unlink(missing_ok=True)
+        return True
+
+    except OSError as e:
+        if e.errno == 3:  # No such process
+            # Process already dead, just remove instance file
+            instance["instance_file"].unlink(missing_ok=True)
+            print_warning(f"Node '{alias}' was already stopped")
+            return True
+        else:
+            print_error(f"Failed to stop node '{alias}': {e}")
+            return False
+
+
+def stop_all_instances(force: bool = False, timeout: int = 10) -> int:
+    """Stop all running node instances."""
+    instances = find_running_instances()
+
+    if not instances:
+        console.print("No running node instances found.")
+        return 0
+
+    console.print(f"Found {len(instances)} running instance(s):")
+    for instance in instances:
+        console.print(f"  - {instance['alias']} (PID: {instance['pid']})")
+
+    console.print("")
+    if force:
+        console.print("Force stopping all instances...")
+    else:
+        console.print("Stopping all instances...")
+
+    success_count = 0
+    for instance in instances:
+        if stop_instance_by_pid(instance, force, timeout):
+            success_count += 1
+
+    if success_count == len(instances):
+        print_success(f"All {success_count} instances stopped successfully")
+        return 0
+    else:
+        print_error(
+            f"Only {success_count}/{len(instances)} instances stopped successfully"
+        )
+        return 1
+
+
+def stop_specific_instance(
+    instance_name: str, force: bool = False, timeout: int = 10
+) -> int:
+    """Stop a specific node instance by name or ID."""
+    instances = find_running_instances()
+
+    if not instances:
+        print_error("No running node instances found")
+        return 1
+
+    # Find matching instance (by alias or instance_id)
+    target_instance = None
+    for instance in instances:
+        if (
+            instance["alias"] == instance_name
+            or instance["instance_id"] == instance_name
+            or instance["instance_id"].startswith(instance_name)
+        ):
+            target_instance = instance
+            break
+
+    if not target_instance:
+        print_error(f"Node instance '{instance_name}' not found")
+        console.print("Running instances:")
+        for instance in instances:
+            console.print(f"  - {instance['alias']} (PID: {instance['pid']})")
+        return 1
+
+    if stop_instance_by_pid(target_instance, force, timeout):
+        print_success(f"Node '{target_instance['alias']}' stopped successfully")
+        return 0
+    else:
+        return 1
+
+
+def stop_command(args: List[str]) -> int:
+    """Handle node stop command.
+
+    Args:
+        args: Command line arguments
+
+    Returns:
+        Exit code (0 for success, non-zero for error)
+    """
+    parser = argparse.ArgumentParser(
+        prog="manta_node stop", description="Stop running node instances"
+    )
+    parser.add_argument(
+        "instance",
+        nargs="?",
+        help="Instance ID or name to stop (if not provided, stops all instances)",
+    )
+    parser.add_argument("--all", action="store_true", help="Stop all running instances")
+    parser.add_argument(
+        "--force",
+        "-f",
+        action="store_true",
+        help="Force stop using SIGKILL instead of SIGTERM",
+    )
+    parser.add_argument(
+        "--timeout",
+        "-t",
+        type=int,
+        default=10,
+        help="Timeout in seconds to wait for graceful shutdown (default: 10)",
+    )
+
+    try:
+        parsed_args = parser.parse_args(args)
+    except SystemExit:
+        return 1
+
+    if parsed_args.all or not parsed_args.instance:
+        return stop_all_instances(parsed_args.force, parsed_args.timeout)
+    else:
+        return stop_specific_instance(
+            parsed_args.instance, parsed_args.force, parsed_args.timeout
+        )
+
+
+if __name__ == "__main__":
+    import sys
+
+    sys.exit(stop_command(sys.argv[1:]))

manta_node/cli/config_manager.py

@@ -0,0 +1,139 @@
+"""
+Compatibility layer for old configuration classes.
+
+This module provides compatibility classes that match the old configuration API
+but delegate to the new NodeConfiguration system.
+"""
+
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+from manta_node.infrastructure.config.node_config_manager import IdentityConfig
+
+from ..infrastructure.config import NodeConfiguration
+
+
+@dataclass
+class ConnectionConfig:
+    """Compatibility class for old ConnectionConfig."""
+
+    host: str = "localhost"
+    port: int = 50051
+    use_tls: bool = False
+    cert_folder: Optional[str] = None
+
+
+@dataclass
+class HardwareConfig:
+    """Compatibility class for old HardwareConfig."""
+
+    gpu_enabled: Optional[bool] = None
+    max_concurrent_tasks: int = 2
+    cpu_limit: str = "2.0"
+    memory_limit: str = "4G"
+
+    def get(self, key: str, default=None):
+        """Make this object behave like a dictionary for compatibility."""
+        return getattr(self, key, default)
+
+    def copy(self):
+        """Return a copy of this hardware config."""
+        return HardwareConfig(
+            gpu_enabled=self.gpu_enabled,
+            max_concurrent_tasks=self.max_concurrent_tasks,
+            cpu_limit=self.cpu_limit,
+            memory_limit=self.memory_limit,
+        )
+
+
+@dataclass
+class NodeConfig:
+    """Compatibility class for old NodeConfig API."""
+
+    name: str
+    alias: str
+    connection: ConnectionConfig
+    hardware: Optional[HardwareConfig] = None
+    datasets: Optional[Dict[str, str]] = None
+    auto_register: bool = True
+    random_id: bool = False
+    created_at: Optional[Any] = None
+    updated_at: Optional[Any] = None
+
+    def __post_init__(self):
+        """Ensure datasets is a proper dict if provided."""
+        if self.datasets is None:
+            self.datasets = {}
+        # Set default timestamps if not provided
+        from datetime import datetime
+
+        if self.created_at is None:
+            self.created_at = datetime.now()
+        if self.updated_at is None:
+            self.updated_at = datetime.now()
+
+    def to_node_configuration(self) -> NodeConfiguration:
+        """Convert to new NodeConfiguration format."""
+        config = NodeConfiguration(
+            identity=IdentityConfig(
+                alias=self.alias, random_id=self.random_id, secured_token=""
+            )
+        )
+
+        # Metadata
+        config.metadata.name = self.name
+
+        # Identity
+        config.identity.alias = self.alias
+        config.identity.random_id = self.random_id
+
+        # Network
+        config.network.manager_host = self.connection.host
+        config.network.manager_port = self.connection.port
+
+        # Security
+        config.security.use_tls = self.connection.use_tls
+        if self.connection.cert_folder:
+            config.security.cert_folder = self.connection.cert_folder
+
+        # Containers/Hardware
+        if self.hardware:
+            config.containers.gpu_enabled = self.hardware.gpu_enabled
+            config.containers.default_cpu_limit = self.hardware.cpu_limit
+            config.containers.default_memory_limit = self.hardware.memory_limit
+            config.tasks.max_concurrent = self.hardware.max_concurrent_tasks
+
+        # Datasets
+        if self.datasets:
+            config.datasets.mappings = self.datasets
+
+        return config
+
+    @classmethod
+    def from_node_configuration(cls, config: NodeConfiguration) -> "NodeConfig":
+        """Create from new NodeConfiguration format."""
+        connection = ConnectionConfig(
+            host=config.network.manager_host,
+            port=config.network.manager_port,
+            use_tls=config.security.use_tls,
+            cert_folder=config.security.cert_folder,
+        )
+
+        hardware = HardwareConfig(
+            gpu_enabled=config.containers.gpu_enabled,
+            max_concurrent_tasks=config.tasks.max_concurrent,
+            cpu_limit=config.containers.default_cpu_limit,
+            memory_limit=config.containers.default_memory_limit,
+        )
+
+        return cls(
+            name=config.metadata.name,
+            alias=config.identity.alias or config.metadata.name,
+            connection=connection,
+            hardware=hardware,
+            datasets=(
+                config.datasets.mappings.copy() if config.datasets.mappings else None
+            ),
+            auto_register=True,  # Default assumption
+            random_id=config.identity.random_id,
+        )

manta_node/cli/main.py

@@ -0,0 +1,133 @@
+"""Manta Node CLI main entry point."""
+
+import sys
+from typing import List, Optional
+
+from rich.console import Console
+
+from .commands.cluster import cluster_command
+from .commands.config import config_command
+from .commands.logs import logs_command
+from .commands.start import start_command
+from .commands.status import status_command
+from .commands.stop import stop_command
+from .version import get_version_string, get_full_version_info
+
+console = Console()
+
+
+def show_version(verbose: bool = False):
+    """Show version information."""
+    if verbose:
+        info = get_full_version_info()
+        console.print(
+            f"[bold cyan]Manta Node[/bold cyan] version [green]{info['version']}[/green]"
+        )
+        console.print(f"  Package version: {info['package_version']}")
+        console.print(f"  Build date:      {info['date']}")
+        console.print(f"  Commit ID:       {info['commit']}")
+    else:
+        console.print(
+            f"[bold cyan]manta_node[/bold cyan] [green]{get_version_string()}[/green]"
+        )
+
+
+def show_help():
+    """Show CLI help information."""
+    help_text = """
+[bold cyan]Manta Node CLI[/bold cyan]
+
+[bold]Usage:[/bold]
+  manta_node <command> [options]
+
+[bold]Commands:[/bold]
+  [cyan]start[/cyan]      Start a node instance
+  [cyan]stop[/cyan]       Stop running node instances
+  [cyan]status[/cyan]     Show status of running nodes
+  [cyan]logs[/cyan]       View node logs
+  [cyan]config[/cyan]     Manage node configurations
+  [cyan]cluster[/cyan]    Manage node clusters
+  [cyan]version[/cyan]    Show version information
+  [cyan]help[/cyan]       Show this help message
+
+[bold]Global Options:[/bold]
+  [cyan]-v, --version[/cyan]   Show version information
+  [cyan]-h, --help[/cyan]      Show this help message
+
+[bold]Examples:[/bold]
+  manta_node start --config default
+  manta_node status --all
+  manta_node logs --follow node-123
+  manta_node config init <path/to/config.yaml>
+  manta_node --version
+
+For more help on a specific command:
+  manta_node <command> --help
+"""
+    console.print(help_text)
+
+
+def main(args: Optional[List[str]] = None) -> int:
+    """Main CLI entry point for manta-node.
+
+    Args:
+        args: Optional command line arguments (uses sys.argv if None)
+
+    Returns:
+        Exit code (0 for success, non-zero for error)
+    """
+    if args is None:
+        args = sys.argv[1:]  # Skip the script name
+
+    # Remove 'node' if it's the first argument (when called as 'manta_node <command>')
+    if args and args[0] == "node":
+        args = args[1:]
+
+    # Show version if requested
+    if args and args[0] in ["-v", "--version", "version"]:
+        # Check for verbose flag
+        verbose = len(args) > 1 and args[1] in ["-v", "--verbose"]
+        show_version(verbose=verbose)
+        return 0
+
+    # Show help if no arguments or help requested
+    if not args or args[0] in ["-h", "--help", "help"]:
+        show_help()
+        return 0
+
+    command = args[0]
+    command_args = args[1:]
+
+    try:
+        # Import and execute the appropriate command
+        if command == "start":
+            return start_command(command_args)
+        elif command == "stop":
+            return stop_command(command_args)
+        elif command == "status":
+            return status_command(command_args)
+        elif command == "logs":
+            return logs_command(command_args)
+        elif command == "config":
+            return config_command(command_args)
+        elif command == "cluster":
+            return cluster_command(command_args)
+        else:
+            console.print(f"[red]Error: Unknown command '{command}'[/red]")
+            console.print("\nUse 'manta_node help' to see available commands.")
+            return 1
+
+    except ImportError as e:
+        console.print(f"[red]Error: Command '{command}' not available[/red]")
+        console.print(f"[dim]{e}[/dim]")
+        return 1
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Operation cancelled by user[/yellow]")
+        return 1
+    except Exception as e:
+        console.print(f"[red]Unexpected error: {e}[/red]")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

manta_node/cli/version.py

@@ -0,0 +1,106 @@
+"""Version information for Manta Node CLI.
+
+Version information is loaded from:
+1. _version_generated.py (created at build time by scripts/generate_version.py)
+2. Fall back to dynamic git detection if not available (development mode)
+"""
+
+import subprocess
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+
+def _load_build_version() -> Optional[dict]:
+    """Try to load version from build-time generated file.
+
+    Returns:
+        Dictionary with build version info, or None if file doesn't exist.
+    """
+    try:
+        # Import the generated version file
+        from . import _version_generated
+
+        return {
+            "version": _version_generated.__version__,
+            "date": _version_generated.__build_date__,
+            "commit": _version_generated.__commit_id__,
+            "package_version": _version_generated.__package_version__,
+        }
+    except ImportError:
+        # Generated file doesn't exist (development mode)
+        return None
+
+
+def _get_git_commit_id() -> Optional[str]:
+    """Get the current git commit ID (short form) dynamically.
+
+    This is used as fallback when build-time version is not available.
+
+    Returns:
+        Short commit ID (first 8 characters) or None if not in a git repo.
+    """
+    try:
+        # Get the directory where this file is located
+        repo_dir = Path(__file__).parent.parent.parent
+
+        result = subprocess.run(
+            ["git", "rev-parse", "--short=8", "HEAD"],
+            cwd=repo_dir,
+            capture_output=True,
+            text=True,
+            timeout=2,
+        )
+
+        if result.returncode == 0:
+            return result.stdout.strip()
+        return None
+    except (subprocess.SubprocessError, FileNotFoundError, subprocess.TimeoutExpired):
+        return None
+
+
+def get_version_string() -> str:
+    """Get version string in format YYYY.MM.DD.COMMIT_ID.
+
+    Returns:
+        Version string like "2025.11.20.c4a8890" or "2025.11.20.unknown" if no version available.
+    """
+    # Try build-time version first
+    build_version = _load_build_version()
+    if build_version:
+        return build_version["version"]
+
+    # Fall back to dynamic git detection (development mode)
+    date_str = datetime.now().strftime("%Y.%m.%d")
+    commit_id = _get_git_commit_id()
+
+    if commit_id:
+        return f"{date_str}.{commit_id}"
+    else:
+        return f"{date_str}.unknown"
+
+
+def get_full_version_info() -> dict:
+    """Get detailed version information.
+
+    Returns:
+        Dictionary with version details.
+    """
+    # Try build-time version first
+    build_version = _load_build_version()
+    if build_version:
+        return build_version
+
+    # Fall back to dynamic detection (development mode)
+    commit_id = _get_git_commit_id()
+
+    return {
+        "version": get_version_string(),
+        "date": datetime.now().strftime("%Y.%m.%d"),
+        "commit": commit_id or "unknown",
+        "package_version": "0.5b0",  # From pyproject.toml
+    }
+
+
+if __name__ == "__main__":
+    print(get_version_string())

manta_node/domain/__init__.py

@@ -0,0 +1,8 @@
+"""Domain layer - Pure business logic with no infrastructure dependencies."""
+
+from .task_lifecycle import TaskLifecycleService, TaskTransitionRule
+
+__all__ = [
+    "TaskLifecycleService",
+    "TaskTransitionRule",
+]