manta-node 0.6b0.dev585__py3-none-any.whl → 0.6b0.dev587__py3-none-any.whl

manta_node/cli/commands/start.py

@@ -21,6 +21,68 @@ from ...node_orchestrator import Node, NodeFatalError
 
 console = Console()
 
+_DEFAULT_LOG_MAX_BYTES = 100 * 1024 * 1024
+
+_SIZE_SUFFIXES = {"K": 1024, "M": 1024**2, "G": 1024**3}
+
+
+def _log_file_max_bytes(declared: str) -> int:
+    """Turn a ``LoggingConfig.max_file_size`` string into a byte count.
+
+    Accepts a bare number of bytes or a K/M/G suffix. An unparsable value falls
+    back to the default rather than raising: this runs on the start path, and
+    refusing to start a node over a typo in a log setting would turn a cosmetic
+    config error into an outage.
+    """
+    text = str(declared).strip().upper().removesuffix("B")
+    multiplier = _SIZE_SUFFIXES.get(text[-1:], 1)
+    if multiplier != 1:
+        text = text[:-1]
+    try:
+        return int(float(text) * multiplier)
+    except ValueError:
+        return _DEFAULT_LOG_MAX_BYTES
+
+
+def _stdout_file_is_held(stdout_file: Path) -> bool:
+    """True when a still-running recorded instance has this path open."""
+    instance_dir = Path.home() / ".manta" / "nodes" / "instances"
+    target = str(stdout_file)
+    try:
+        recorded = sorted(instance_dir.glob("*.json"))
+    except OSError:
+        # Unknown counts as held, and the asymmetry is deliberate: a roll
+        # skipped under a dead writer costs disk, one performed under a live
+        # writer costs that writer's output.
+        return True
+
+    for instance_file in recorded:
+        try:
+            data = json.loads(instance_file.read_text())
+        except (OSError, ValueError):
+            continue
+        # `isinstance` and not `.get`: a JSON list or bare string parses fine and
+        # has no `.get`, and the AttributeError would escape both this function
+        # and the caller's `except OSError` to land in `start_node_background`'s
+        # `except Exception` -- a node that will not start because a file in an
+        # unrelated directory is malformed.
+        if not isinstance(data, dict) or data.get("stdout_file") != target:
+            continue
+        pid = data.get("pid")
+        # `pid > 0` is load-bearing, not a range check: os.kill(0, ...) addresses
+        # the caller's whole process group and os.kill(-1, ...) every process it
+        # may signal. This pid is read from a file on disk, so it is untrusted.
+        if not isinstance(pid, int) or isinstance(pid, bool) or pid <= 0:
+            continue
+        try:
+            os.kill(pid, 0)
+        except ProcessLookupError:
+            continue
+        except OSError:
+            pass  # Alive, but not ours to signal (EPERM). Still a writer.
+        return True
+    return False
+
 
 def print_error(message: str):
     """Print error message in red."""
@@ -172,22 +234,42 @@ def start_node_foreground(
                 },
             },
             "handlers": {
+                # NEVER give this handler `mode: "w"`, and never swap it back to
+                # a plain FileHandler. This file is the only untruncated account
+                # of a crash, and it is opened by the restart the crash causes:
+                # truncating on open destroys the evidence of the very incident
+                # a reader came for. Rotation is what keeps that append bounded.
                 "file": {
-                    "class": "logging.FileHandler",
+                    "class": "logging.handlers.RotatingFileHandler",
                     "formatter": "standard",
                     "filename": log_config.filename,
                     "filters": ["manta_filter"],
-                    "mode": "w",
-                },
-                "rich": {
-                    "class": "rich.logging.RichHandler",
-                    "formatter": "standard",
-                    "markup": True,
-                    "filters": ["manta_filter"],
-                    "console": Console(
-                        _environ={"COLUMNS": "284"},
-                    ),
+                    "maxBytes": _log_file_max_bytes(log_config.max_file_size),
+                    "backupCount": log_config.backup_count,
                 },
+                # Rich elides each line to the console width as it renders, so
+                # what systemd captures is already cut -- `journalctl` cannot
+                # restore characters that were never written. Under a unit there
+                # is no tty, and the journal is then the only surviving record,
+                # so it gets a plain handler that formats the message whole.
+                # Rich stays for an operator running the node interactively.
+                "console": (
+                    {
+                        "class": "rich.logging.RichHandler",
+                        "formatter": "standard",
+                        "markup": True,
+                        "filters": ["manta_filter"],
+                        "console": Console(
+                            _environ={"COLUMNS": "284"},
+                        ),
+                    }
+                    if sys.stdout.isatty()
+                    else {
+                        "class": "logging.StreamHandler",
+                        "formatter": "standard",
+                        "filters": ["manta_filter"],
+                    }
+                ),
             },
             "root": {"level": log_config.level, "handlers": []},
         }
@@ -196,7 +278,7 @@ def start_node_foreground(
         if log_config.log_to_file:
             config_dict["root"]["handlers"].append("file")
         if log_config.log_to_console:
-            config_dict["root"]["handlers"].append("rich")
+            config_dict["root"]["handlers"].append("console")
 
         # Call configure_logging with the config dictionary
         configure_logging(config=config_dict, debug=log_config.debug_mode)
@@ -304,8 +386,35 @@ def start_node_background(
         # Ensure log directory exists
         log_file.parent.mkdir(parents=True, exist_ok=True)
 
-        # Start subprocess
-        with open(log_file, "w") as log:
+        # One writer per path, and NEVER `log_file`: the child rotates that
+        # path, and a rename does not retarget an fd already open here, so this
+        # stream would follow the orphaned inode down the .1/.2 chain and be
+        # deleted at backupCount -- taking with it any traceback written before
+        # logging is configured.
+        # The suffix must stay off `.log`: logs.py globs `*.log` beside this
+        # file and keys by stem, so a `.log` sibling appears as a second node
+        # and defeats the single-instance auto-select.
+        stdout_file = log_file.with_suffix(".stdout")
+
+        # Bounds an append that never truncates. One previous run is kept: it is
+        # what explains the restart that replaced it.
+        # Rolled BEFORE the fd is opened, and never while another instance holds
+        # it. A rename does not retarget an already-open fd, so either mistake
+        # leaves a writer appending to an inode the next roll unlinks.
+        max_bytes = _log_file_max_bytes(config_manager.config.logging.max_file_size)
+        try:
+            if stdout_file.stat().st_size >= max_bytes and not _stdout_file_is_held(
+                stdout_file
+            ):
+                stdout_file.replace(stdout_file.with_name(f"{stdout_file.name}.1"))
+        except OSError:
+            # Housekeeping on a log file, running inside the caller's `except
+            # Exception`: anything escaping here becomes a node that will not
+            # start. Failing to roll costs disk; failing to start costs the node.
+            pass
+
+        # Append, never "w": a restart must not erase the run that prompted it.
+        with open(stdout_file, "a") as log:
             proc = subprocess.Popen(
                 cmd,
                 stdout=log,
@@ -337,6 +446,7 @@ def start_node_background(
                 "manager_host": config_manager.config.network.manager_host,
                 "manager_port": config_manager.config.network.manager_port,
                 "log_file": str(log_file),
+                "stdout_file": str(stdout_file),
             }
 
             with open(instance_file, "w") as f:
@@ -344,7 +454,11 @@ def start_node_background(
 
             return 0
         else:
+            # stdout_file first: a node that died this early never reached
+            # configure_logging, so log_file holds nothing about it.
             print_error("Node failed to start. Check logs for details.")
+            if stdout_file.exists():
+                console.print(f"Startup output: {stdout_file}")
             if log_file.exists():
                 console.print(f"Log file: {log_file}")
             return 1

{manta_node-0.6b0.dev585.dist-info → manta_node-0.6b0.dev587.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: manta_node
-Version: 0.6b0.dev585
+Version: 0.6b0.dev587
 Summary: Node side software of the Manta platform. It is responsible for the communication with the Manta Core and the execution of the tasks.
 Author-email: Hugo Miralles <hugo.miralles@manta-tech.io>, Matthew Thompson <matthew.thompson@manta-tech.io>
 License-Expression: AGPL-3.0-or-later

{manta_node-0.6b0.dev585.dist-info → manta_node-0.6b0.dev587.dist-info}/RECORD

@@ -13,7 +13,7 @@ manta_node/cli/commands/cluster.py,sha256=kUVopCN4xkEk-IR1aKpr7bfBSQEtG6pEj_hlWn
 manta_node/cli/commands/config.py,sha256=BiarCD0S8rcNYbio4RLzDvUS7A50s5dd5F4TiZqLR6M,16577
 manta_node/cli/commands/logs.py,sha256=cXOSdwhDIJAiKMmJYdzrnpapIxudxVdMzYT-KAWDKVk,5259
 manta_node/cli/commands/network.py,sha256=QqncD6vbNlg65ptQdFYexEUMALQm8UwcftbW3sfQrjw,42070
-manta_node/cli/commands/start.py,sha256=8qpOTv4LsCAMaygmPyhC9ZqlH8rkFPko-u2bVYTvyIo,18771
+manta_node/cli/commands/start.py,sha256=5l6AG3nBvJqu3TrqtBSBAHVR71o1YWAlUHWiYOL2Bos,24547
 manta_node/cli/commands/status.py,sha256=FhlJuFxIRzxv9y8jUJRuWaCLfDBsGBqv6DCHUFQta3A,6401
 manta_node/cli/commands/stop.py,sha256=8on7NqqaBeHRcbrZ5pGJ3Ms_6E_HNcF22mZ908JVu4A,7695
 manta_node/domain/__init__.py,sha256=uyJXDf0QgfGCsXLMggqKCB5QV9oneYJ4iM-REaJGXDM,217
@@ -50,9 +50,9 @@ manta_node/infrastructure/process/executor.py,sha256=Ab1XvNuelEGCD5KdZLgYYnpjYZ5
 manta_node/infrastructure/security/__init__.py,sha256=lI6vkbUmfmt0m363iO4HzuzVNoQAc7Clp2R5vAhZbgE,64
 manta_node/infrastructure/security/auth_agent.py,sha256=WkPTg_g0gix7xomb_on_Ft3TNX0FpeqS7gwgJW9mTvk,11037
 manta_node/infrastructure/security/token_provider.py,sha256=u3bcbQYNBskFzunO-wOSZpGkDN_CU1BCB5HUbZTC4Vg,1832
-manta_node-0.6b0.dev585.dist-info/licenses/LICENSE,sha256=9mBgLhiB9goQPQjg9XQJ6FjgVxYw9Q8lyOZYkPGwF_c,34484
-manta_node-0.6b0.dev585.dist-info/METADATA,sha256=ondVpeyOG7n76C7roKaiYN_oeysKmokIxrKJI8Lolhg,4213
-manta_node-0.6b0.dev585.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-manta_node-0.6b0.dev585.dist-info/entry_points.txt,sha256=C_zcw6mdmztNxVUZGLZ83UH5TwcSuqb2C-rB4e2CQoc,56
-manta_node-0.6b0.dev585.dist-info/top_level.txt,sha256=nbT5J5WETuXM9UPoQckl29uUOq8wMYdRb9QDx5kAFeo,11
-manta_node-0.6b0.dev585.dist-info/RECORD,,
+manta_node-0.6b0.dev587.dist-info/licenses/LICENSE,sha256=9mBgLhiB9goQPQjg9XQJ6FjgVxYw9Q8lyOZYkPGwF_c,34484
+manta_node-0.6b0.dev587.dist-info/METADATA,sha256=UmduRXnFC2bzwzzQa06NsSBDwAo6gdrilYwV2WnEcHE,4213
+manta_node-0.6b0.dev587.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+manta_node-0.6b0.dev587.dist-info/entry_points.txt,sha256=C_zcw6mdmztNxVUZGLZ83UH5TwcSuqb2C-rB4e2CQoc,56
+manta_node-0.6b0.dev587.dist-info/top_level.txt,sha256=nbT5J5WETuXM9UPoQckl29uUOq8wMYdRb9QDx5kAFeo,11
+manta_node-0.6b0.dev587.dist-info/RECORD,,