| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133 |
- """Host resources the screen needs before it starts: memory.
- A headed desktop is a big allocation relative to a small gateway host: Xvnc + Xfce idle at ~220 MiB
- and the browser a human opens during a takeover adds 500 MiB to 1 GiB (measured in the official image:
- gateway 304 MiB → +Xfce 520 MiB → +Chromium on one page 1,073 MiB). On a 4 GB container the loser
- of that squeeze is Chromium, killed mid-login, or the gateway itself. So ``runtime.start()`` refuses
- while the host cannot spare ``bot_desktop.min_free_memory_mb`` and ``display.status`` says why, which
- the pane shows in place of the Start button.
- "Available" is the tighter of two numbers: what the cgroup still allows (a container limit; v2
- ``memory.max``/``memory.current``, v1 ``memory.limit_in_bytes``/``memory.usage_in_bytes``) and what
- the kernel reports free for the whole machine (``MemAvailable``) — a limit of 8 GB on a 4 GB host is
- not 8 GB.
- """
- from __future__ import annotations
- from dataclasses import dataclass
- from pathlib import Path
- from typing import Optional
- _CGROUP_V2 = Path("/sys/fs/cgroup")
- _CGROUP_V1 = Path("/sys/fs/cgroup/memory")
- _MEMINFO = Path("/proc/meminfo")
- _MIB = 1024 * 1024
- DEFAULT_MIN_FREE_MB = 1536
- @dataclass
- class MemoryInfo:
- available_mb: Optional[int] # None when nothing readable (non-Linux, odd sandboxes)
- limit_mb: Optional[int] # the cgroup limit when there is one, else the machine's MemTotal
- def _read_int(path: Path) -> Optional[int]:
- try:
- text = path.read_text(encoding="utf-8-sig").strip()
- except OSError:
- return None
- return int(text) if text.isdigit() else None # "max" → None
- def _meminfo() -> dict[str, int]:
- try:
- lines = _MEMINFO.read_text(encoding="utf-8-sig").splitlines()
- except OSError:
- return {}
- out: dict[str, int] = {}
- for line in lines:
- key, _, rest = line.partition(":")
- parts = rest.split()
- if parts and parts[0].isdigit():
- out[key] = int(parts[0]) * 1024 # kB
- return out
- def _stat_value(path: Path, key: str) -> Optional[int]:
- """One ``<key> <bytes>`` line out of a cgroup ``memory.stat``."""
- try:
- for line in path.read_text(encoding="utf-8-sig").splitlines():
- name, _, rest = line.partition(" ")
- if name == key:
- return int(rest.strip())
- except (OSError, ValueError):
- return None
- return None
- def _cgroup_limit_and_usage() -> tuple[Optional[int], Optional[int]]:
- """The cgroup's limit and its *working set* — usage minus reclaimable page cache.
- ``memory.current`` counts page cache, so a container reads several hundred MB above idle right after a
- desktop stops with every process gone. Charging that would make the gate tighten over uptime, so we
- subtract ``inactive_file``, the working-set convention kubelet uses.
- """
- limit = _read_int(_CGROUP_V2 / "memory.max")
- usage = _read_int(_CGROUP_V2 / "memory.current")
- cache = _stat_value(_CGROUP_V2 / "memory.stat", "inactive_file")
- if limit is None and usage is None:
- limit = _read_int(_CGROUP_V1 / "memory.limit_in_bytes")
- usage = _read_int(_CGROUP_V1 / "memory.usage_in_bytes")
- cache = _stat_value(_CGROUP_V1 / "memory.stat", "total_inactive_file")
- if limit is not None and limit >= 1 << 60: # v1 "unlimited" is a huge sentinel
- limit = None
- if usage is not None and cache:
- usage = max(usage - cache, 0)
- return limit, usage
- def memory_info() -> MemoryInfo:
- info = _meminfo()
- host_available = info.get("MemAvailable")
- host_total = info.get("MemTotal")
- limit, usage = _cgroup_limit_and_usage()
- candidates = [x for x in (host_available, (limit - usage) if limit is not None and usage is not None else None)
- if x is not None]
- available = min(candidates) if candidates else None
- limit_bytes = limit if limit is not None else host_total
- return MemoryInfo(available_mb=None if available is None else max(0, available // _MIB),
- limit_mb=None if limit_bytes is None else limit_bytes // _MIB)
- def min_free_mb() -> int:
- """``bot_desktop.min_free_memory_mb``; 0 disables the gate. A hosted deployment sets it in the
- instance's config.yaml (or the managed overlay), not an env var."""
- from hermes_cli.config import load_config_readonly
- cfg = load_config_readonly().get("bot_desktop") or {}
- try:
- return max(0, int(cfg.get("min_free_memory_mb", DEFAULT_MIN_FREE_MB)))
- except (TypeError, ValueError):
- return DEFAULT_MIN_FREE_MB
- def tight_headroom_mb(floor: Optional[int] = None) -> int:
- """Above the floor but below this, a start is allowed and logged: the desktop fits, a few browser tabs
- would not. Derived from the floor so raising the floor cannot silently retire the warning."""
- floor = min_free_mb() if floor is None else floor
- return floor + floor // 3
- def memory_blocker(info: Optional[MemoryInfo] = None, need: Optional[int] = None) -> Optional[str]:
- """Why the screen must not start now, or None. Unknown memory is not a blocker: a host we cannot
- read is not a host we know to be small. ``need`` lets a caller that also wants
- :func:`tight_headroom_mb` read the floor once instead of loading the config twice."""
- need = min_free_mb() if need is None else need
- if need == 0:
- return None
- info = info or memory_info()
- if info.available_mb is None or info.available_mb >= need:
- return None
- limit = f" of {info.limit_mb} MB" if info.limit_mb else ""
- return (f"Not enough free memory for a desktop: {info.available_mb} MB available{limit}, "
- f"{need} MB needed (bot_desktop.min_free_memory_mb)")
|