wnm 0.0.12__py3-none-any.whl

wnm/__init__.py

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

wnm/__main__.py

@@ -0,0 +1,236 @@
+import json
+import logging
+import os
+import sys
+import time
+
+from sqlalchemy import insert, select
+
+from wnm.config import (
+    LOCK_FILE,
+    S,
+    apply_config_updates,
+    config_updates,
+    machine_config,
+    options,
+)
+from wnm.decision_engine import DecisionEngine
+from wnm.executor import ActionExecutor
+from wnm.migration import survey_machine
+from wnm.models import Node
+from wnm.utils import (
+    get_antnode_version,
+    get_machine_metrics,
+    update_counters,
+)
+
+logging.basicConfig(level=logging.INFO)
+# Info level logging for sqlalchemy is too verbose, only use when needed
+logging.getLogger("sqlalchemy.engine.Engine").disabled = True
+
+
+# A storage place for ant node data
+Workers = []
+
+# Detect ANM
+
+
+# Make a decision about what to do (new implementation using DecisionEngine)
+def choose_action(machine_config, metrics, dry_run):
+    """Plan and execute actions using DecisionEngine and ActionExecutor.
+
+    This function now acts as a thin wrapper around the new decision engine
+    and action executor classes.
+
+    Args:
+        machine_config: Machine configuration dictionary
+        metrics: Current system metrics
+        dry_run: If True, log actions without executing
+
+    Returns:
+        Dictionary with execution status
+    """
+    # Check records for expired status (must be done before planning)
+    if not dry_run:
+        metrics = update_counters(S, metrics, machine_config)
+
+    # Handle nodes with no version number (done before planning)
+    if metrics["nodes_no_version"] > 0:
+        if dry_run:
+            logging.warning("DRYRUN: Update NoVersion nodes")
+        else:
+            with S() as session:
+                no_version = session.execute(
+                    select(Node.timestamp, Node.id, Node.binary)
+                    .where(Node.version == "")
+                    .order_by(Node.timestamp.asc())
+                ).all()
+            # Iterate through nodes with no version number
+            for check in no_version:
+                # Update version number from binary
+                version = get_antnode_version(check[2])
+                logging.info(
+                    f"Updating version number for node {check[1]} to {version}"
+                )
+                with S() as session:
+                    session.query(Node).filter(Node.id == check[1]).update(
+                        {"version": version}
+                    )
+                    session.commit()
+
+    # Use the new DecisionEngine to plan actions
+    engine = DecisionEngine(machine_config, metrics)
+    actions = engine.plan_actions()
+
+    # Log the computed features for debugging
+    logging.info(json.dumps(engine.get_features(), indent=2))
+
+    # Use ActionExecutor to execute the planned actions
+    executor = ActionExecutor(S)
+    result = executor.execute(actions, machine_config, metrics, dry_run)
+
+    return result
+
+
+def main():
+
+    # Are we already running
+    if os.path.exists(LOCK_FILE):
+        logging.warning("wnm still running")
+        sys.exit(1)
+
+    # We're starting, so lets create a lock file
+    try:
+        with open(LOCK_FILE, "w") as file:
+            file.write(str(int(time.time())))
+    except (PermissionError, OSError) as e:
+        logging.error(f"Unable to create lock file: {e}")
+        sys.exit(1)
+
+    # Config should have loaded the machine_config
+    if machine_config:
+        logging.info("Machine: " + json.dumps(machine_config))
+    else:
+        logging.error("Unable to load machine config, exiting")
+        sys.exit(1)
+    # Check for config updates
+    if config_updates:
+        logging.info("Update: " + json.dumps(config_updates))
+        if options.dry_run:
+            logging.warning("Dry run, not saving requested updates")
+            # Create a dictionary for the machine config
+            # Machine by default returns a parameter array,
+            # use the __json__ method to return a dict
+            local_config = json.loads(json.dumps(machine_config))
+            # Apply the local config with the requested updates
+            local_config.update(config_updates)
+        else:
+            # Store the config changes to the database
+            apply_config_updates(config_updates)
+            # Create a working dictionary for the machine config
+            # Machine by default returns a parameter array,
+            # use the __json__ method to return a dict
+            local_config = json.loads(json.dumps(machine_config))
+    else:
+        local_config = json.loads(json.dumps(machine_config))
+
+    metrics = get_machine_metrics(
+        S,
+        local_config["node_storage"],
+        local_config["hd_remove"],
+        local_config["crisis_bytes"],
+    )
+    logging.info(json.dumps(metrics, indent=2))
+
+    # Do we already have nodes
+    if metrics["total_nodes"] == 0:
+        # Are we migrating an anm server
+        if options.init and options.migrate_anm:
+            Workers = survey_machine(machine_config) or []
+            if Workers:
+                if options.dry_run:
+                    logging.warning(f"DRYRUN: Not saving {len(Workers)} detected nodes")
+                else:
+                    with S() as session:
+                        session.execute(insert(Node), Workers)
+                        session.commit()
+                    # Reload metrics
+                    metrics = get_machine_metrics(
+                        S,
+                        local_config["node_storage"],
+                        local_config["hd_remove"],
+                        local_config["crisis_bytes"],
+                    )
+                logging.info(
+                    "Found {counter} nodes defined".format(
+                        counter=metrics["total_nodes"]
+                    )
+                )
+            else:
+                logging.warning("Requested migration but no nodes found")
+        else:
+            logging.info("No nodes found")
+    else:
+        logging.info(
+            "Found {counter} nodes configured".format(counter=metrics["total_nodes"])
+        )
+
+    # Check for reports
+    if options.report:
+        from wnm.reports import generate_node_status_report, generate_node_status_details_report
+
+        # If survey action is specified, run it first
+        if options.force_action == "survey":
+            logging.info("Running survey before generating report")
+            executor = ActionExecutor(S)
+            survey_result = executor.execute_forced_action(
+                "survey",
+                local_config,
+                metrics,
+                service_name=options.service_name,
+                dry_run=options.dry_run,
+            )
+            logging.info(f"Survey result: {survey_result}")
+
+        # Generate the report
+        if options.report == "node-status":
+            report_output = generate_node_status_report(
+                S, options.service_name, options.report_format
+            )
+        elif options.report == "node-status-details":
+            report_output = generate_node_status_details_report(
+                S, options.service_name, options.report_format
+            )
+        else:
+            report_output = f"Unknown report type: {options.report}"
+
+        print(report_output)
+        os.remove(LOCK_FILE)
+        sys.exit(0)
+
+    # Check for forced actions
+    if options.force_action:
+        logging.info(f"Executing forced action: {options.force_action}")
+        executor = ActionExecutor(S)
+        this_action = executor.execute_forced_action(
+            options.force_action,
+            local_config,
+            metrics,
+            service_name=options.service_name,
+            dry_run=options.dry_run,
+            count=options.count if hasattr(options, 'count') else 1,
+        )
+    else:
+        this_action = choose_action(local_config, metrics, options.dry_run)
+
+    print("Action:", json.dumps(this_action, indent=2))
+
+    os.remove(LOCK_FILE)
+    sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
+    # print(options.MemRemove)
+
+print("End of program")

wnm/actions.py

@@ -0,0 +1,45 @@
+"""Action model for representing planned node operations.
+
+This module defines the action types and data structures used by the decision engine
+to represent planned operations on nodes.
+"""
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Optional
+
+
+class ActionType(Enum):
+    """Types of actions that can be performed on nodes."""
+
+    ADD_NODE = "add"
+    REMOVE_NODE = "remove"
+    UPGRADE_NODE = "upgrade"
+    START_NODE = "start"
+    STOP_NODE = "stop"
+    RESTART_NODE = "restart"
+    SURVEY_NODES = "survey"
+    RESURVEY_NODES = "resurvey"
+
+
+@dataclass
+class Action:
+    """Represents a planned action to be executed.
+
+    Attributes:
+        type: The type of action to perform
+        node_id: Optional node ID if action is node-specific
+        priority: Higher values indicate more urgent actions (default: 0)
+        reason: Human-readable explanation of why this action is needed
+    """
+
+    type: ActionType
+    node_id: Optional[int] = None
+    priority: int = 0
+    reason: str = ""
+
+    def __repr__(self) -> str:
+        """Return a string representation of the action."""
+        if self.node_id is not None:
+            return f"Action({self.type.value}, node={self.node_id}, reason={self.reason})"
+        return f"Action({self.type.value}, reason={self.reason})"

wnm/common.py

@@ -0,0 +1,23 @@
+# Primary node for want of one
+QUEEN = 1
+
+# Donation address, default to faucet vault, can be overridden in config
+DONATE = "0x00455d78f850b0358E8cea5be24d415E01E107CF"
+# Faucet address, to allow faucet donation and another donate address
+FAUCET = "0x00455d78f850b0358E8cea5be24d415E01E107CF"
+
+# Keep these as strings so they can be grepped in logs
+STOPPED = "STOPPED"  # 0 Node is not responding to it's metrics port
+RUNNING = "RUNNING"  # 1 Node is responding to it's metrics port
+UPGRADING = "UPGRADING"  # 2 Upgrade in progress
+DISABLED = "DISABLED"  # -1 Do not start
+RESTARTING = "RESTARTING"  # 3 re/starting a server intionally
+MIGRATING = "MIGRATING"  # 4 Moving volumes in progress
+REMOVING = "REMOVING"  # 5 Removing node in progress
+DEAD = "DEAD"  # -86 Broken node to cleanup
+
+# Magic numbers extracted from codebase
+MIN_NODES_THRESHOLD = 0  # Minimum nodes before considering actions
+PORT_MULTIPLIER = 1000  # Port calculation: PortStart * 1000 + node_id
+METRICS_PORT_BASE = 13000  # Metrics port calculation: 13000 + node_id
+DEFAULT_CRISIS_BYTES = 2 * 10**9  # Default crisis threshold in bytes (2GB)