wnm 0.0.10__tar.gz → 0.0.11__tar.gz

{wnm-0.0.10 → wnm-0.0.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wnm
-Version: 0.0.10
+Version: 0.0.11
 Summary: Manager for Autonomi nodes
 Author-email: Troy Johnson <troy@weave.sh>
 License: GPL-3.0

{wnm-0.0.10 → wnm-0.0.11}/src/wnm/__init__.py

@@ -1,3 +1,3 @@
 """A service to manage a cluster of decentralized Autonomi nodes"""
 
-__version__ = "0.0.10"
+__version__ = "0.0.11"

{wnm-0.0.10 → wnm-0.0.11}/src/wnm/process_managers/systemd_manager.py

@@ -8,11 +8,12 @@ Requires sudo privileges for systemctl and firewall operations.
 import logging
 import os
 import re
+import shutil
 import subprocess
 import time
 
 from wnm.common import DEAD, RESTARTING, RUNNING, STOPPED, UPGRADING
-from wnm.config import BOOTSTRAP_CACHE_DIR, LOG_DIR
+from wnm.config import BOOTSTRAP_CACHE_DIR, IS_ROOT, LOG_DIR
 from wnm.models import Node
 from wnm.process_managers.base import NodeProcess, ProcessManager
 from wnm.utils import (
@@ -24,7 +25,7 @@ from wnm.utils import (
 
 
 class SystemdManager(ProcessManager):
-    """Manage nodes as systemd services"""
+    """Manage nodes as systemd services (system or user mode)"""
 
     def __init__(self, session_factory=None, firewall_type: str = None):
         """
@@ -32,11 +33,29 @@ class SystemdManager(ProcessManager):
 
         Args:
             session_factory: SQLAlchemy session factory (optional, for status updates)
-            firewall_type: Type of firewall to use (defaults to auto-detect)
+            firewall_type: Type of firewall to use (defaults to auto-detect, null for non-root)
         """
+        # Determine if we're using system or user services
+        # Root users use system services in /etc/systemd/system/
+        # Non-root users use user services in ~/.config/systemd/user/
+        self.use_system_services = IS_ROOT
+
+        # Non-root users should use null firewall by default (to avoid sudo)
+        if not IS_ROOT and firewall_type is None:
+            firewall_type = "null"
+
         super().__init__(firewall_type)
         self.S = session_factory
 
+        if self.use_system_services:
+            self.service_dir = "/etc/systemd/system"
+            self.systemctl_cmd = ["sudo", "systemctl"]
+        else:
+            self.service_dir = os.path.expanduser("~/.config/systemd/user")
+            self.systemctl_cmd = ["systemctl", "--user"]
+            # Create user service directory if it doesn't exist
+            os.makedirs(self.service_dir, exist_ok=True)
+
     def create_node(self, node: Node, binary_path: str) -> bool:
         """
         Create and start a new node as a systemd service.
@@ -55,70 +74,113 @@ class SystemdManager(ProcessManager):
         log_dir = f"{LOG_DIR}/antnode{node.node_name}"
 
         # Create directories
-        try:
-            subprocess.run(
-                ["sudo", "mkdir", "-p", node.root_dir, log_dir],
-                stdout=subprocess.PIPE,
-                check=True,
-            )
-        except subprocess.CalledProcessError as err:
-            logging.error(f"Failed to create directories: {err}")
-            return False
+        if self.use_system_services:
+            # Root: use sudo for system paths
+            try:
+                subprocess.run(
+                    ["sudo", "mkdir", "-p", node.root_dir, log_dir],
+                    stdout=subprocess.PIPE,
+                    check=True,
+                )
+            except subprocess.CalledProcessError as err:
+                logging.error(f"Failed to create directories: {err}")
+                return False
+        else:
+            # Non-root: create in user paths without sudo
+            try:
+                os.makedirs(node.root_dir, exist_ok=True)
+                os.makedirs(log_dir, exist_ok=True)
+            except OSError as err:
+                logging.error(f"Failed to create directories: {err}")
+                return False
 
         # Copy binary to node directory
-        try:
-            subprocess.run(
-                ["sudo", "cp", binary_path, node.root_dir],
-                stdout=subprocess.PIPE,
-                check=True,
-            )
-        except subprocess.CalledProcessError as err:
-            logging.error(f"Failed to copy binary: {err}")
-            return False
+        if self.use_system_services:
+            # Root: use sudo to copy
+            try:
+                subprocess.run(
+                    ["sudo", "cp", binary_path, node.root_dir],
+                    stdout=subprocess.PIPE,
+                    check=True,
+                )
+            except subprocess.CalledProcessError as err:
+                logging.error(f"Failed to copy binary: {err}")
+                return False
+        else:
+            # Non-root: copy as current user
+            try:
+                shutil.copy2(binary_path, node.root_dir)
+                binary_dest = os.path.join(node.root_dir, "antnode")
+                os.chmod(binary_dest, 0o755)
+            except (OSError, shutil.Error) as err:
+                logging.error(f"Failed to copy binary: {err}")
+                return False
 
-        # Change ownership
-        user = getattr(node, "user", "ant")
-        try:
-            subprocess.run(
-                ["sudo", "chown", "-R", f"{user}:{user}", node.root_dir, log_dir],
-                stdout=subprocess.PIPE,
-                check=True,
-            )
-        except subprocess.CalledProcessError as err:
-            logging.error(f"Failed to change ownership: {err}")
-            return False
+        # Change ownership (only when running as root)
+        # When running as non-root user, files remain owned by current user
+        if self.use_system_services:
+            user = getattr(node, "user", "ant")
+            try:
+                subprocess.run(
+                    ["sudo", "chown", "-R", f"{user}:{user}", node.root_dir, log_dir],
+                    stdout=subprocess.PIPE,
+                    check=True,
+                )
+            except subprocess.CalledProcessError as err:
+                logging.error(f"Failed to change ownership: {err}")
+                return False
 
         # Build systemd service unit
         env_string = f'Environment="{node.environment}"' if node.environment else ""
         binary_in_node_dir = f"{node.root_dir}/antnode"
 
+        # Determine which user to run as
+        # System services (root): use 'ant' user for security
+        # User services (non-root): don't specify User= (runs as current user)
+        if self.use_system_services:
+            user = getattr(node, "user", "ant")
+            user_line = f"User={user}"
+        else:
+            user_line = ""  # User services run as the invoking user
+
         service_content = f"""[Unit]
 Description=antnode{node.node_name}
 [Service]
 {env_string}
-User={user}
+{user_line}
 ExecStart={binary_in_node_dir} --bootstrap-cache-dir {BOOTSTRAP_CACHE_DIR} --root-dir {node.root_dir} --port {node.port} --enable-metrics-server --metrics-server-port {node.metrics_port} --log-output-dest {log_dir} --max-log-files 1 --max-archived-log-files 1 --rewards-address {node.wallet} {node.network}
 Restart=always
 #RestartSec=300
 """
 
         # Write service file
-        try:
-            subprocess.run(
-                ["sudo", "tee", f"/etc/systemd/system/{service_name}"],
-                input=service_content,
-                text=True,
-                stdout=subprocess.PIPE,
-                check=True,
-            )
-        except subprocess.CalledProcessError as err:
-            logging.error(f"Failed to write service file: {err}")
-            return False
+        service_path = f"{self.service_dir}/{service_name}"
+        if self.use_system_services:
+            # System services: use sudo to write to /etc/systemd/system
+            try:
+                subprocess.run(
+                    ["sudo", "tee", service_path],
+                    input=service_content,
+                    text=True,
+                    stdout=subprocess.PIPE,
+                    check=True,
+                )
+            except subprocess.CalledProcessError as err:
+                logging.error(f"Failed to write service file: {err}")
+                return False
+        else:
+            # User services: write directly to ~/.config/systemd/user
+            try:
+                with open(service_path, "w") as f:
+                    f.write(service_content)
+            except OSError as err:
+                logging.error(f"Failed to write service file: {err}")
+                return False
 
         # Reload systemd
         try:
             subprocess.run(
-                ["sudo", "systemctl", "daemon-reload"],
+                self.systemctl_cmd + ["daemon-reload"],
                 stdout=subprocess.PIPE,
                 check=True,
             )
@@ -144,7 +206,7 @@ Restart=always
         # Start service
         try:
             result = subprocess.run(
-                ["sudo", "systemctl", "start", node.service],
+                self.systemctl_cmd + ["start", node.service],
                 stdout=subprocess.PIPE,
                 stderr=subprocess.STDOUT,
                 text=True,
@@ -176,7 +238,7 @@ Restart=always
         # Stop service
         try:
             subprocess.run(
-                ["sudo", "systemctl", "stop", node.service],
+                self.systemctl_cmd + ["stop", node.service],
                 stdout=subprocess.PIPE,
                 check=True,
             )
@@ -203,7 +265,7 @@ Restart=always
 
         try:
             subprocess.run(
-                ["sudo", "systemctl", "restart", node.service],
+                self.systemctl_cmd + ["restart", node.service],
                 stdout=subprocess.PIPE,
                 check=True,
             )
@@ -225,7 +287,8 @@ Restart=always
         """
         try:
             result = subprocess.run(
-                ["systemctl", "show", node.service, "--property=MainPID,ActiveState"],
+                self.systemctl_cmd
+                + ["show", node.service, "--property=MainPID,ActiveState"],
                 stdout=subprocess.PIPE,
                 text=True,
                 check=True,
@@ -274,29 +337,51 @@ Restart=always
         self.stop_node(node)
 
         nodename = f"antnode{node.node_name}"
+        log_path = f"{LOG_DIR}/{nodename}"
 
         # Remove data and logs
-        try:
-            subprocess.run(
-                ["sudo", "rm", "-rf", node.root_dir, f"{LOG_DIR}/{nodename}"],
-                check=True,
-            )
-        except subprocess.CalledProcessError as err:
-            logging.error(f"Failed to remove node data: {err}")
+        if self.use_system_services:
+            # System services: use sudo to remove
+            try:
+                subprocess.run(
+                    ["sudo", "rm", "-rf", node.root_dir, log_path],
+                    check=True,
+                )
+            except subprocess.CalledProcessError as err:
+                logging.error(f"Failed to remove node data: {err}")
+        else:
+            # User services: remove as current user
+            try:
+                if os.path.exists(node.root_dir):
+                    shutil.rmtree(node.root_dir)
+                if os.path.exists(log_path):
+                    shutil.rmtree(log_path)
+            except (OSError, shutil.Error) as err:
+                logging.error(f"Failed to remove node data: {err}")
 
         # Remove service file
-        try:
-            subprocess.run(
-                ["sudo", "rm", "-f", f"/etc/systemd/system/{node.service}"],
-                check=True,
-            )
-        except subprocess.CalledProcessError as err:
-            logging.error(f"Failed to remove service file: {err}")
+        service_path = f"{self.service_dir}/{node.service}"
+        if self.use_system_services:
+            # System services: use sudo to remove
+            try:
+                subprocess.run(
+                    ["sudo", "rm", "-f", service_path],
+                    check=True,
+                )
+            except subprocess.CalledProcessError as err:
+                logging.error(f"Failed to remove service file: {err}")
+        else:
+            # User services: remove as current user
+            try:
+                if os.path.exists(service_path):
+                    os.remove(service_path)
+            except OSError as err:
+                logging.error(f"Failed to remove service file: {err}")
 
         # Reload systemd
         try:
             subprocess.run(
-                ["sudo", "systemctl", "daemon-reload"],
+                self.systemctl_cmd + ["daemon-reload"],
                 stdout=subprocess.PIPE,
                 check=True,
             )
@@ -309,7 +394,7 @@ Restart=always
         """
         Survey all systemd-managed antnode services.
 
-        Scans /etc/systemd/system for antnode*.service files and
+        Scans systemd service directory (system or user) for antnode*.service files and
         collects their configuration and current status.
 
         Args:
@@ -318,17 +403,16 @@ Restart=always
         Returns:
             List of node dictionaries ready for database insertion
         """
-        systemd_dir = "/etc/systemd/system"
         service_names = []
 
-        # Scan for antnode service files
-        if os.path.exists(systemd_dir):
+        # Scan for antnode service files in the appropriate directory
+        if os.path.exists(self.service_dir):
             try:
-                for file in os.listdir(systemd_dir):
+                for file in os.listdir(self.service_dir):
                     if re.match(r"antnode[\d]+\.service", file):
                         service_names.append(file)
             except PermissionError as e:
-                logging.error(f"Permission denied reading {systemd_dir}: {e}")
+                logging.error(f"Permission denied reading {self.service_dir}: {e}")
                 return []
             except Exception as e:
                 logging.error(f"Error listing systemd services: {e}")
@@ -405,7 +489,7 @@ Restart=always
             Dictionary with node configuration, or empty dict on error
         """
         details = {}
-        service_path = f"/etc/systemd/system/{service_name}"
+        service_path = f"{self.service_dir}/{service_name}"
 
         try:
             with open(service_path, "r") as file:
@@ -413,7 +497,9 @@ Restart=always
 
             details["id"] = int(re.findall(r"antnode(\d+)", service_name)[0])
             details["binary"] = re.findall(r"ExecStart=([^ ]+)", data)[0]
-            details["user"] = re.findall(r"User=(\w+)", data)[0]
+            # User field may be empty for user services
+            user_matches = re.findall(r"User=(\w+)", data)
+            details["user"] = user_matches[0] if user_matches else os.getenv("USER", "nobody")
             details["root_dir"] = re.findall(r"--root-dir ([\w\/]+)", data)[0]
             details["port"] = int(re.findall(r"--port (\d+)", data)[0])
             details["metrics_port"] = int(

{wnm-0.0.10 → wnm-0.0.11}/src/wnm/reports.py

@@ -117,13 +117,13 @@ class NodeReporter:
         lines = []
 
         # Header
-        header = f"{'Service Name':<20}{'Peer ID':<50}{'Status':<15}{'Connected Peers':>15}"
+        header = f"{'Service Name':<20}{'Peer ID':<55}{'Status':<15}{'Connected Peers':>15}"
         lines.append(header)
 
         # Node rows
         for node in nodes:
             service_col = f"{node.service:<20}"
-            peer_id_col = f"{(node.peer_id or '-'):<50}"
+            peer_id_col = f"{(node.peer_id or '-'):<55}"
             status_col = f"{node.status:<15}"
             # Connected peers from connected_peers field
             peers = node.connected_peers if node.connected_peers is not None else 0

{wnm-0.0.10 → wnm-0.0.11}/src/wnm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wnm
-Version: 0.0.10
+Version: 0.0.11
 Summary: Manager for Autonomi nodes
 Author-email: Troy Johnson <troy@weave.sh>
 License: GPL-3.0