wnm 0.0.9__py3-none-any.whl → 0.0.10__py3-none-any.whl

wnm/process_managers/base.py

@@ -0,0 +1,203 @@
+"""
+Abstract base class for process managers.
+
+Process managers handle node lifecycle operations across different
+execution environments (systemd, docker, setsid, etc.)
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Optional
+
+from wnm.firewall.factory import get_firewall_manager
+from wnm.models import Node
+
+
+@dataclass
+class NodeProcess:
+    """Represents the runtime state of a node process"""
+
+    node_id: int
+    pid: Optional[int] = None
+    status: str = "UNKNOWN"  # RUNNING, STOPPED, UPGRADING, etc.
+    container_id: Optional[str] = None  # For docker-managed nodes
+
+
+class ProcessManager(ABC):
+    """
+    Abstract interface for node lifecycle management.
+
+    Each implementation handles a specific process management backend:
+    - SystemdManager: systemd services (Linux)
+    - DockerManager: Docker containers
+    - SetsidManager: Background processes via setsid
+    - AntctlManager: Wrapper around antctl CLI
+    - LaunchctlManager: macOS launchd services
+    """
+
+    def __init__(self, firewall_type: str = None):
+        """
+        Initialize process manager with optional firewall manager.
+
+        Args:
+            firewall_type: Type of firewall to use ("ufw", "null", etc.)
+                          If None, auto-detects best available option
+        """
+        self.firewall = get_firewall_manager(firewall_type)
+
+    @abstractmethod
+    def create_node(self, node: Node, binary_path: str) -> bool:
+        """
+        Create and start a new node.
+
+        Args:
+            node: Node database record with configuration
+            binary_path: Path to the node binary to execute
+
+        Returns:
+            True if node was created successfully
+        """
+        pass
+
+    @abstractmethod
+    def start_node(self, node: Node) -> bool:
+        """
+        Start a stopped node.
+
+        Args:
+            node: Node database record
+
+        Returns:
+            True if node started successfully
+        """
+        pass
+
+    @abstractmethod
+    def stop_node(self, node: Node) -> bool:
+        """
+        Stop a running node.
+
+        Args:
+            node: Node database record
+
+        Returns:
+            True if node stopped successfully
+        """
+        pass
+
+    @abstractmethod
+    def restart_node(self, node: Node) -> bool:
+        """
+        Restart a node.
+
+        Args:
+            node: Node database record
+
+        Returns:
+            True if node restarted successfully
+        """
+        pass
+
+    @abstractmethod
+    def get_status(self, node: Node) -> NodeProcess:
+        """
+        Get current runtime status of a node.
+
+        Args:
+            node: Node database record
+
+        Returns:
+            NodeProcess with current status and PID
+        """
+        pass
+
+    @abstractmethod
+    def remove_node(self, node: Node) -> bool:
+        """
+        Stop and remove all traces of a node.
+
+        This should:
+        1. Stop the node process
+        2. Remove service/container definitions
+        3. Optionally clean up data directories (controlled by node.keep_data)
+
+        Args:
+            node: Node database record
+
+        Returns:
+            True if node was removed successfully
+        """
+        pass
+
+    @abstractmethod
+    def survey_nodes(self, machine_config) -> list:
+        """
+        Survey all nodes managed by this process manager.
+
+        This is used during database initialization/rebuild to discover
+        existing nodes by scanning the manager's configuration directory.
+        Each manager handles its own path logic internally.
+
+        The database is the source of truth for regular operations.
+        This method is ONLY used for initialization and migration.
+
+        Args:
+            machine_config: Machine configuration object
+
+        Returns:
+            List of node dictionaries ready for database insertion
+        """
+        pass
+
+    def enable_firewall_port(
+        self, port: int, protocol: str = "udp", comment: str = None
+    ) -> bool:
+        """
+        Open firewall port for node communication.
+
+        Uses the configured firewall manager to open the port.
+        Subclasses can override for custom firewall behavior.
+
+        Args:
+            port: Port number to open
+            protocol: Protocol type (udp/tcp)
+            comment: Optional comment for the firewall rule
+
+        Returns:
+            True if port was opened successfully
+        """
+        return self.firewall.enable_port(port, protocol, comment)
+
+    def disable_firewall_port(self, port: int, protocol: str = "udp") -> bool:
+        """
+        Close firewall port when node is removed.
+
+        Uses the configured firewall manager to close the port.
+        Subclasses can override for custom firewall behavior.
+
+        Args:
+            port: Port number to close
+            protocol: Protocol type (udp/tcp)
+
+        Returns:
+            True if port was closed successfully
+        """
+        return self.firewall.disable_port(port, protocol)
+
+    def teardown_cluster(self) -> bool:
+        """
+        Teardown the entire cluster using manager-specific commands.
+
+        This is an optional method that managers can override to provide
+        efficient bulk teardown operations. If not overridden, returns False
+        to indicate that individual node removal should be used instead.
+
+        Examples:
+            - AntctlManager: Uses 'antctl reset' command
+            - Other managers: Return False to use default individual removal
+
+        Returns:
+            True if cluster was torn down successfully using manager-specific method,
+            False to indicate fallback to individual node removal
+        """
+        return False

wnm/process_managers/docker_manager.py

@@ -0,0 +1,371 @@
+"""
+DockerManager: Manage nodes in Docker containers.
+
+This manager runs nodes inside Docker containers, allowing for better isolation
+and resource management. Supports both single-node and multi-node containers.
+"""
+
+import logging
+import os
+import re
+import subprocess
+import time
+from pathlib import Path
+
+from wnm.common import DEAD, RESTARTING, RUNNING, STOPPED, UPGRADING
+from wnm.config import BOOTSTRAP_CACHE_DIR
+from wnm.models import Node
+from wnm.process_managers.base import NodeProcess, ProcessManager
+
+
+class DockerManager(ProcessManager):
+    """Manage nodes in Docker containers"""
+
+    def __init__(
+        self,
+        session_factory=None,
+        image="autonomi/node:latest",
+        firewall_type: str = "null",
+    ):
+        """
+        Initialize DockerManager.
+
+        Args:
+            session_factory: SQLAlchemy session factory (optional, for status updates)
+            image: Docker image to use for nodes
+            firewall_type: Type of firewall (defaults to "null" for Docker)
+        """
+        super().__init__(firewall_type)
+        self.S = session_factory
+        self.image = image
+
+    def _get_container_name(self, node: Node) -> str:
+        """Get Docker container name for a node"""
+        return f"antnode{node.node_name}"
+
+    def _ensure_image(self) -> bool:
+        """Ensure Docker image is available"""
+        try:
+            # Check if image exists locally
+            result = subprocess.run(
+                ["docker", "image", "inspect", self.image],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+            if result.returncode == 0:
+                return True
+
+            # Pull image if not found
+            logging.info(f"Pulling Docker image: {self.image}")
+            subprocess.run(
+                ["docker", "pull", self.image],
+                check=True,
+            )
+            return True
+
+        except subprocess.CalledProcessError as err:
+            logging.error(f"Failed to ensure Docker image: {err}")
+            return False
+
+    def create_node(self, node: Node, binary_path: str) -> bool:
+        """
+        Create and start a new node in a Docker container.
+
+        Args:
+            node: Node database record with configuration
+            binary_path: Path to the antnode binary (will be mounted into container)
+
+        Returns:
+            True if node was created successfully
+        """
+        logging.info(f"Creating docker node {node.id}")
+
+        # Ensure image is available
+        if not self._ensure_image():
+            return False
+
+        # Prepare directories
+        node_dir = Path(node.root_dir)
+        try:
+            node_dir.mkdir(parents=True, exist_ok=True)
+        except OSError as err:
+            logging.error(f"Failed to create node directory: {err}")
+            return False
+
+        container_name = self._get_container_name(node)
+
+        # Build docker run command
+        cmd = [
+            "docker",
+            "run",
+            "-d",  # Detached mode
+            "--name",
+            container_name,
+            "--restart",
+            "unless-stopped",
+            # Port mappings
+            "-p",
+            f"{node.port}:{node.port}/udp",
+            "-p",
+            f"{node.metrics_port}:{node.metrics_port}/tcp",
+            # Volume mounts
+            "-v",
+            f"{node.root_dir}:/data",
+            "-v",
+            f"{binary_path}:/usr/local/bin/antnode:ro",
+            "-v",
+            f"{BOOTSTRAP_CACHE_DIR}:/bootstrap-cache:ro",
+        ]
+
+        # Add environment variables
+        if node.environment:
+            for env_var in node.environment.split():
+                cmd.extend(["-e", env_var])
+
+        # Add the image
+        cmd.append(self.image)
+
+        # Add the command to run
+        cmd.extend(
+            [
+                "antnode",
+                "--root-dir",
+                "/data",
+                "--port",
+                str(node.port),
+                "--enable-metrics-server",
+                "--metrics-server-port",
+                str(node.metrics_port),
+                "--bootstrap-cache-dir",
+                "/bootstrap-cache",
+                "--rewards-address",
+                node.wallet,
+                node.network,
+            ]
+        )
+
+        # Run the container
+        try:
+            result = subprocess.run(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                check=True,
+            )
+            container_id = result.stdout.strip()
+            logging.info(f"Created container {container_name} with ID {container_id}")
+
+        except subprocess.CalledProcessError as err:
+            logging.error(f"Failed to create container: {err}")
+            logging.error(f"stderr: {err.stderr}")
+            return False
+
+        # Update database with container info if we have Container model support
+        # For now, we'll store container_id in node metadata if needed
+
+        # Wait a moment for container to start
+        time.sleep(1)
+
+        return True
+
+    def start_node(self, node: Node) -> bool:
+        """
+        Start a stopped Docker container.
+
+        Args:
+            node: Node database record
+
+        Returns:
+            True if node started successfully
+        """
+        logging.info(f"Starting docker node {node.id}")
+
+        container_name = self._get_container_name(node)
+
+        try:
+            subprocess.run(
+                ["docker", "start", container_name],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                check=True,
+            )
+        except subprocess.CalledProcessError as err:
+            logging.error(f"Failed to start container: {err}")
+            return False
+
+        return True
+
+    def stop_node(self, node: Node) -> bool:
+        """
+        Stop a Docker container.
+
+        Args:
+            node: Node database record
+
+        Returns:
+            True if node stopped successfully
+        """
+        logging.info(f"Stopping docker node {node.id}")
+
+        container_name = self._get_container_name(node)
+
+        try:
+            # Stop with 30 second timeout for graceful shutdown
+            subprocess.run(
+                ["docker", "stop", "-t", "30", container_name],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                check=True,
+            )
+        except subprocess.CalledProcessError as err:
+            logging.error(f"Failed to stop container: {err}")
+            return False
+
+        return True
+
+    def restart_node(self, node: Node) -> bool:
+        """
+        Restart a Docker container.
+
+        Args:
+            node: Node database record
+
+        Returns:
+            True if node restarted successfully
+        """
+        logging.info(f"Restarting docker node {node.id}")
+
+        container_name = self._get_container_name(node)
+
+        try:
+            subprocess.run(
+                ["docker", "restart", "-t", "30", container_name],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                check=True,
+            )
+        except subprocess.CalledProcessError as err:
+            logging.error(f"Failed to restart container: {err}")
+            return False
+
+        return True
+
+    def get_status(self, node: Node) -> NodeProcess:
+        """
+        Get current status of a Docker node.
+
+        Args:
+            node: Node database record
+
+        Returns:
+            NodeProcess with current status
+        """
+        container_name = self._get_container_name(node)
+
+        try:
+            # Get container info
+            result = subprocess.run(
+                [
+                    "docker",
+                    "inspect",
+                    "--format",
+                    "{{.State.Status}}|{{.State.Pid}}|{{.Id}}",
+                    container_name,
+                ],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                check=True,
+            )
+
+            status_str, pid_str, container_id = result.stdout.strip().split("|")
+
+            # Map Docker status to our status
+            if status_str == "running":
+                status = RUNNING
+            elif status_str in ("created", "restarting"):
+                status = RESTARTING
+            elif status_str in ("exited", "dead"):
+                status = STOPPED
+            else:
+                status = "UNKNOWN"
+
+            pid = int(pid_str) if pid_str and pid_str != "0" else None
+
+            # Check if root directory exists
+            if not os.path.isdir(node.root_dir):
+                status = DEAD
+
+            return NodeProcess(
+                node_id=node.id,
+                pid=pid,
+                status=status,
+                container_id=container_id,
+            )
+
+        except subprocess.CalledProcessError:
+            # Container doesn't exist
+            return NodeProcess(node_id=node.id, pid=None, status=STOPPED)
+        except (ValueError, IndexError) as err:
+            logging.error(f"Failed to parse container status: {err}")
+            return NodeProcess(node_id=node.id, pid=None, status="UNKNOWN")
+
+    def remove_node(self, node: Node) -> bool:
+        """
+        Stop and remove a Docker container.
+
+        Args:
+            node: Node database record
+
+        Returns:
+            True if node was removed successfully
+        """
+        logging.info(f"Removing docker node {node.id}")
+
+        container_name = self._get_container_name(node)
+
+        # Stop the container first
+        self.stop_node(node)
+
+        # Remove the container
+        try:
+            subprocess.run(
+                ["docker", "rm", "-f", container_name],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                check=True,
+            )
+        except subprocess.CalledProcessError as err:
+            logging.error(f"Failed to remove container: {err}")
+
+        # Remove node data directory
+        try:
+            import shutil
+
+            node_dir = Path(node.root_dir)
+            if node_dir.exists():
+                shutil.rmtree(node_dir)
+        except (OSError, Exception) as err:
+            logging.error(f"Failed to remove node directory: {err}")
+
+        return True
+
+    def survey_nodes(self, machine_config) -> list:
+        """
+        Survey all docker-managed antnode containers.
+
+        Docker nodes are typically not used for migration scenarios.
+        This returns an empty list as docker containers are created
+        fresh by WNM and don't pre-exist.
+
+        Args:
+            machine_config: Machine configuration object
+
+        Returns:
+            Empty list (docker nodes don't pre-exist for migration)
+        """
+        logging.info(
+            "Docker survey not implemented (docker nodes created fresh by WNM)"
+        )
+        return []

wnm/process_managers/factory.py

@@ -0,0 +1,83 @@
+"""
+Factory for creating process manager instances.
+
+Provides a centralized way to instantiate the appropriate process manager
+based on the manager type.
+"""
+
+import logging
+
+from wnm.process_managers.base import ProcessManager
+from wnm.process_managers.docker_manager import DockerManager
+from wnm.process_managers.launchd_manager import LaunchctlManager
+from wnm.process_managers.setsid_manager import SetsidManager
+from wnm.process_managers.systemd_manager import SystemdManager
+
+
+def get_process_manager(
+    manager_type: str, session_factory=None, **kwargs
+) -> ProcessManager:
+    """
+    Get a process manager instance for the specified type.
+
+    Args:
+        manager_type: Type of process manager ("systemd", "docker", "setsid", etc.)
+        session_factory: SQLAlchemy session factory for database operations
+        **kwargs: Additional arguments to pass to the manager constructor
+
+    Returns:
+        ProcessManager instance
+
+    Raises:
+        ValueError: If manager_type is not supported
+    """
+    managers = {
+        "systemd": SystemdManager,
+        "docker": DockerManager,
+        "setsid": SetsidManager,
+        "launchctl": LaunchctlManager,
+        # Future managers:
+        # "antctl": AntctlManager,
+    }
+
+    manager_class = managers.get(manager_type)
+    if not manager_class:
+        supported = ", ".join(managers.keys())
+        raise ValueError(
+            f"Unsupported manager type: {manager_type}. "
+            f"Supported types: {supported}"
+        )
+
+    logging.debug(f"Creating {manager_type} process manager")
+    return manager_class(session_factory=session_factory, **kwargs)
+
+
+def get_default_manager_type() -> str:
+    """
+    Determine the default process manager type for the current system.
+
+    Returns:
+        Default manager type string ("systemd", "setsid", etc.)
+    """
+    import platform
+    import shutil
+
+    system = platform.system()
+
+    # Linux: prefer systemd if available
+    if system == "Linux":
+        if shutil.which("systemctl"):
+            return "systemd"
+        return "setsid"
+
+    # macOS: use launchctl for native macOS support
+    if system == "Darwin":
+        return "launchctl"
+
+    # Windows: not supported
+    if system == "Windows":
+        raise RuntimeError("Windows is not currently supported")
+
+    # Unknown system: fall back to setsid
+    logging.warning(f"Unknown system {system}, defaulting to setsid manager")
+    return "setsid"