psrsentinel 1.0.3__tar.gz

psrsentinel-1.0.3/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: psrsentinel
+Version: 1.0.3
+Summary: Jodrell bank pulsar server monitor
+Author: Benjamin Shaw
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: PyYAML<6.0,>=3.13; python_version < "3.10"
+Requires-Dist: PyYAML>=6.0; python_version >= "3.10"
+Requires-Dist: typing_extensions>=4.0; python_version < "3.8"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: tox; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"

psrsentinel-1.0.3/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "psrsentinel"
+version = "1.0.3"
+description = "Jodrell bank pulsar server monitor"
+readme = "README.md"
+requires-python = ">=3.6"
+license = { file = "LICENSE" }
+authors = [{ name = "Benjamin Shaw" }]
+dependencies = [
+    "PyYAML>=3.13,<6.0; python_version < '3.10'",
+    "PyYAML>=6.0; python_version >= '3.10'",
+    "typing_extensions>=4.0; python_version<'3.8'"
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "tox",
+    "isort",
+    "flake8",
+    "black",
+    "build",
+    "twine",
+]
+
+[project.scripts]
+psrsentinel = "psrsentinel.app:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

psrsentinel-1.0.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

psrsentinel-1.0.3/src/psrsentinel/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

psrsentinel-1.0.3/src/psrsentinel/__main__.py

@@ -0,0 +1,4 @@
+from psrsentinel.app import main
+
+if __name__ == "__main__":
+    main()

psrsentinel-1.0.3/src/psrsentinel/api/adapter.py

@@ -0,0 +1,44 @@
+import socket
+
+from psrsentinel import __version__
+from psrsentinel.state import (
+    collect_states,
+    combine_states,
+    iso_after_seconds,
+    make_summary,
+    map_to_psrmon_state,
+    utc_now_iso,
+)
+
+
+def make_psrmon_payload(machine, checks, polling_config, collector_config):
+    internal_state = combine_states(collect_states(checks))
+    hostname = machine.get("hostname") or socket.gethostname()
+    module_id = machine.get("module_id", "host-{0}".format(hostname))
+    report_timeout = int(polling_config.get("report_timeout_seconds", 45))
+
+    return {
+        "module_id": module_id,
+        "module_type": "host",
+        "host": hostname,
+        "timestamp": utc_now_iso(),
+        "timeout_timestamp": iso_after_seconds(report_timeout),
+        "overall_state": map_to_psrmon_state(internal_state),
+        "summary": make_summary(checks),
+        "diagnostics_ok": internal_state != "UNKNOWN",
+        "payload_version": "1.0",
+        "data": {
+            "collector": {
+                "type": "local_agent",
+                "host": socket.gethostname(),
+                "version": __version__,
+                "config_version": collector_config.get(
+                    "config_version", "unknown"
+                ),
+                "agent": "psrsentinel",
+            },
+            "role": machine.get("role", "unknown"),
+            "location": machine.get("location", "unknown"),
+            "checks": checks,
+        },
+    }

psrsentinel-1.0.3/src/psrsentinel/api/client.py

@@ -0,0 +1,41 @@
+import json
+from urllib import error, request
+
+
+class PostError(RuntimeError):
+    pass
+
+
+def post_payload(base_url, api_key, payload, timeout_seconds=5):
+    module_id = payload["module_id"]
+    endpoint = "{0}/api/modules/{1}/state".format(
+        base_url.rstrip("/"), module_id
+    )
+
+    body = json.dumps(payload, separators=(",", ":")).encode("utf-8")
+
+    headers = {
+        "Content-Type": "application/json",
+    }
+    if api_key:
+        headers["Authorization"] = "Bearer {0}".format(api_key)
+
+    req = request.Request(endpoint, data=body, headers=headers, method="POST")
+
+    try:
+        with request.urlopen(req, timeout=timeout_seconds) as response:
+            raw = response.read().decode("utf-8")
+            if not raw:
+                return {}
+            try:
+                return json.loads(raw)
+            except ValueError:
+                return {"raw_response": raw}
+    except error.HTTPError as exc:
+        try:
+            detail = exc.read().decode("utf-8")
+        except Exception:
+            detail = str(exc)
+        raise PostError("HTTP {0}: {1}".format(exc.code, detail))
+    except error.URLError as exc:
+        raise PostError(str(exc))

psrsentinel-1.0.3/src/psrsentinel/app.py

@@ -0,0 +1,183 @@
+import argparse
+import json
+import sys
+import time
+
+from psrsentinel.api.adapter import make_psrmon_payload
+from psrsentinel.api.client import post_payload
+from psrsentinel.checks.load import check_load
+from psrsentinel.checks.memory import check_memory
+from psrsentinel.checks.mounts import check_expected_mounts
+from psrsentinel.checks.processes import check_expected_processes
+from psrsentinel.checks.services import check_expected_services
+from psrsentinel.checks.storage import check_storage
+from psrsentinel.checks.time_sync import check_time_sync
+from psrsentinel.config import get_api_key, load_config
+from psrsentinel.hostname import find_machine_config
+from psrsentinel.scheduler import (
+    CheckSchedule,
+    get_interval_seconds,
+    shortest_interval,
+)
+
+CHECKS = {
+    "expected_processes": check_expected_processes,
+    "expected_services": check_expected_services,
+    "expected_mounts": check_expected_mounts,
+    "storage": check_storage,
+    "memory": check_memory,
+    "load": check_load,
+    "time_sync": check_time_sync,
+}
+
+
+class Agent(object):
+    def __init__(self, config, machine, no_post=False, pretty=False):
+        self.config = config
+        self.machine = machine
+        self.no_post = no_post
+        self.pretty = pretty
+        self.schedule = CheckSchedule()
+        self.latest_checks = {}
+
+    def run_once(self, force_all=False):
+        checks_config = self.machine.get("checks", {})
+        intervals = self.config.get("polling", {}).get("intervals", {})
+        ran_any = False
+
+        for check_name, check_config in checks_config.items():
+            if not check_config.get("enabled", False):
+                continue
+
+            due = force_all
+            if not due:
+                interval = get_interval_seconds(check_config, intervals)
+                due = self.schedule.should_run(check_name, interval)
+
+            if not due:
+                continue
+
+            self.latest_checks[check_name] = self._run_check(
+                check_name, check_config
+            )
+            self.schedule.mark_run(check_name)
+            ran_any = True
+
+        if ran_any or force_all:
+            payload = make_psrmon_payload(
+                self.machine,
+                self.latest_checks,
+                self.config.get("polling", {}),
+                self.config.get("collector", {}),
+            )
+            self.emit(payload)
+            return payload
+
+        return None
+
+    def run_forever(self):
+        intervals = self.config.get("polling", {}).get("intervals", {})
+        sleep_seconds = shortest_interval(intervals)
+
+        # Prime the cache with all enabled checks, then move to due-only checks.
+        self.run_once(force_all=True)
+
+        while True:
+            started = time.monotonic()
+            self.run_once(force_all=False)
+            elapsed = time.monotonic() - started
+            time.sleep(max(1, sleep_seconds - elapsed))
+
+    def _run_check(self, check_name, check_config):
+        func = CHECKS.get(check_name)
+        if func is None:
+            return {
+                "state": "UNKNOWN",
+                "message": "No check registered for {0}".format(check_name),
+            }
+
+        try:
+            return func(check_config)
+        except Exception as exc:
+            return {
+                "state": "UNKNOWN",
+                "message": "Check {0} raised {1}: {2}".format(
+                    check_name, type(exc).__name__, exc
+                ),
+            }
+
+    def emit(self, payload):
+        if self.pretty:
+            print(json.dumps(payload, indent=2, sort_keys=True))
+        else:
+            print(json.dumps(payload, sort_keys=True))
+        sys.stdout.flush()
+
+        api_config = self.config.get("api", {})
+        if self.no_post or not api_config.get("enabled", False):
+            return
+
+        api_key = get_api_key(api_config)
+        try:
+            post_payload(
+                api_config["base_url"],
+                api_key,
+                payload,
+                timeout_seconds=int(api_config.get("timeout_seconds", 5)),
+            )
+        except Exception as exc:
+            print("POST failed: {0}".format(exc), file=sys.stderr)
+            sys.stderr.flush()
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Local psrsentinel health agent"
+    )
+    parser.add_argument(
+        "--config",
+        default="config/machines.yaml",
+        help="Path to shared YAML config",
+    )
+    parser.add_argument(
+        "--hostname",
+        help="Override local hostname when selecting machine config",
+    )
+    parser.add_argument(
+        "--once",
+        action="store_true",
+        help="Run all enabled checks once and exit",
+    )
+    parser.add_argument(
+        "--no-post",
+        action="store_true",
+        help="Do not POST to psrmon even if API is enabled",
+    )
+    parser.add_argument(
+        "--pretty", action="store_true", help="Pretty-print JSON"
+    )
+    parser.add_argument(
+        "--show-machine",
+        action="store_true",
+        help="Print the selected machine config and exit",
+    )
+
+    args = parser.parse_args()
+
+    config = load_config(args.config)
+    machine = find_machine_config(config, args.hostname)
+
+    if args.show_machine:
+        print(json.dumps(machine, indent=2, sort_keys=True))
+        return
+
+    agent = Agent(config, machine, no_post=args.no_post, pretty=args.pretty)
+
+    if args.once:
+        agent.run_once(force_all=True)
+    else:
+        agent.run_forever()
+
+
+if __name__ == "__main__":
+    main()

psrsentinel-1.0.3/src/psrsentinel/checks/load.py

@@ -0,0 +1,41 @@
+import os
+
+
+def check_load(check_config):
+    try:
+        load_1, load_5, load_15 = os.getloadavg()
+    except OSError as exc:
+        return {"state": "UNKNOWN", "message": str(exc)}
+
+    cores = os.cpu_count() or 1
+    warn_per_core = float(check_config.get("warn_1min_per_core", 1.5))
+    fail_per_core = float(check_config.get("fail_1min_per_core", 3.0))
+    load_per_core = load_1 / float(cores)
+
+    if load_per_core >= fail_per_core:
+        state = "FAILED"
+        message = (
+            "1-minute load per core {0:.2f} >= fail threshold {1:.2f}".format(
+                load_per_core, fail_per_core
+            )
+        )
+    elif load_per_core >= warn_per_core:
+        state = "DEGRADED"
+        message = (
+            "1-minute load per core {0:.2f} >= warn threshold {1:.2f}".format(
+                load_per_core, warn_per_core
+            )
+        )
+    else:
+        state = "OK"
+        message = None
+
+    return {
+        "state": state,
+        "load_average": [load_1, load_5, load_15],
+        "cores": cores,
+        "load_1min_per_core": load_per_core,
+        "warn_1min_per_core": warn_per_core,
+        "fail_1min_per_core": fail_per_core,
+        "message": message,
+    }

psrsentinel-1.0.3/src/psrsentinel/checks/memory.py

@@ -0,0 +1,53 @@
+from psrsentinel.command import run_command
+
+
+def check_memory(check_config):
+    result = run_command(["free", "-m"])
+    if result.returncode != 0:
+        return {
+            "state": "UNKNOWN",
+            "message": result.stderr or "Could not run free",
+        }
+
+    parsed = parse_free_m(result.stdout)
+    if parsed is None:
+        return {"state": "UNKNOWN", "message": "Could not parse free output"}
+
+    min_available_mb = int(check_config.get("min_available_mb", 1024))
+    available_mb = parsed["available_mb"]
+
+    if available_mb < min_available_mb:
+        state = "DEGRADED"
+        message = "Available memory {0} MB < threshold {1} MB".format(
+            available_mb, min_available_mb
+        )
+    else:
+        state = "OK"
+        message = None
+
+    return {
+        "state": state,
+        "total_mb": parsed["total_mb"],
+        "used_mb": parsed["used_mb"],
+        "available_mb": available_mb,
+        "min_available_mb": min_available_mb,
+        "message": message,
+    }
+
+
+def parse_free_m(output):
+    for line in output.splitlines():
+        if not line.startswith("Mem:"):
+            continue
+        parts = line.split()
+        if len(parts) < 7:
+            return None
+        try:
+            return {
+                "total_mb": int(parts[1]),
+                "used_mb": int(parts[2]),
+                "available_mb": int(parts[6]),
+            }
+        except ValueError:
+            return None
+    return None

psrsentinel-1.0.3/src/psrsentinel/checks/mounts.py

@@ -0,0 +1,58 @@
+import os
+
+
+def check_expected_mounts(check_config):
+    items = []
+    for item in check_config.get("items", []) or []:
+        items.append(check_path(item))
+
+    states = [item.get("state", "UNKNOWN") for item in items]
+    if "FAILED" in states:
+        state = "FAILED"
+    elif "DEGRADED" in states:
+        state = "DEGRADED"
+    elif "UNKNOWN" in states:
+        state = "UNKNOWN"
+    else:
+        state = "OK"
+
+    return {"state": state, "items": items}
+
+
+def check_path(item):
+    path = item["path"]
+    required = bool(item.get("required", True))
+    must_exist = bool(item.get("must_exist", True))
+    must_be_readable = bool(item.get("must_be_readable", False))
+    must_be_writable = bool(item.get("must_be_writable", False))
+
+    exists = os.path.exists(path)
+    readable = os.access(path, os.R_OK)
+    writable = os.access(path, os.W_OK)
+    mountpoint = os.path.ismount(path)
+
+    failures = []
+    if must_exist and not exists:
+        failures.append("path does not exist")
+    if must_be_readable and not readable:
+        failures.append("path is not readable")
+    if must_be_writable and not writable:
+        failures.append("path is not writable")
+
+    if failures:
+        state = "FAILED" if required else "DEGRADED"
+        message = ", ".join(failures)
+    else:
+        state = "OK"
+        message = None
+
+    return {
+        "path": path,
+        "state": state,
+        "required": required,
+        "exists": exists,
+        "readable": readable,
+        "writable": writable,
+        "is_mountpoint": mountpoint,
+        "message": message,
+    }

psrsentinel-1.0.3/src/psrsentinel/checks/processes.py

@@ -0,0 +1,87 @@
+from psrsentinel.command import run_command
+
+
+def check_expected_processes(check_config):
+    items = []
+    for proc in check_config.get("items", []) or []:
+        items.append(check_expected_process(proc))
+
+    states = [item.get("state", "UNKNOWN") for item in items]
+    if "FAILED" in states:
+        state = "FAILED"
+    elif "DEGRADED" in states:
+        state = "DEGRADED"
+    elif "UNKNOWN" in states:
+        state = "UNKNOWN"
+    else:
+        state = "OK"
+
+    return {"state": state, "items": items}
+
+
+def check_expected_process(proc):
+    pattern = proc["pattern"]
+    min_count = int(proc.get("min_count", 1))
+    max_count = proc.get("max_count")
+    if max_count is not None:
+        max_count = int(max_count)
+    required = bool(proc.get("required", True))
+
+    result = run_command(["pgrep", "-af", pattern])
+
+    if result.returncode not in (0, 1):
+        return {
+            "name": proc.get("name", pattern),
+            "pattern": pattern,
+            "state": "UNKNOWN",
+            "expected": required,
+            "running": False,
+            "match_count": 0,
+            "matches": [],
+            "message": result.stderr or "Could not run pgrep",
+        }
+
+    matches = []
+    if result.returncode == 0 and result.stdout:
+        for line in result.stdout.splitlines():
+            parts = line.split(None, 1)
+            if not parts:
+                continue
+            try:
+                pid = int(parts[0])
+            except ValueError:
+                continue
+            command = parts[1] if len(parts) > 1 else ""
+            matches.append({"pid": pid, "command": command})
+
+    count = len(matches)
+    if count < min_count:
+        state = "FAILED" if required else "DEGRADED"
+        message = (
+            "Expected at least {0} matching process(es), found {1}".format(
+                min_count, count
+            )
+        )
+    elif max_count is not None and count > max_count:
+        state = "DEGRADED"
+        message = (
+            "Expected at most {0} matching process(es), found {1}".format(
+                max_count, count
+            )
+        )
+    else:
+        state = "OK"
+        message = None
+
+    return {
+        "name": proc.get("name", pattern),
+        "pattern": pattern,
+        "state": state,
+        "expected": required,
+        "running": count >= min_count,
+        "match_count": count,
+        "min_count": min_count,
+        "max_count": max_count,
+        "matches": matches,
+        "message": message,
+    }

psrsentinel-1.0.3/src/psrsentinel/checks/services.py

@@ -0,0 +1,39 @@
+from psrsentinel.command import run_command
+
+
+def check_expected_services(check_config):
+    items = []
+    for service in check_config.get("items", []) or []:
+        name = service["name"]
+        required = bool(service.get("required", True))
+        result = run_command(["systemctl", "is-active", name])
+        active = result.stdout.strip() == "active"
+
+        if active:
+            state = "OK"
+            message = None
+        else:
+            state = "FAILED" if required else "DEGRADED"
+            message = result.stdout or result.stderr or "Service is not active"
+
+        items.append(
+            {
+                "name": name,
+                "state": state,
+                "active": active,
+                "required": required,
+                "message": message,
+            }
+        )
+
+    states = [item.get("state", "UNKNOWN") for item in items]
+    if "FAILED" in states:
+        state = "FAILED"
+    elif "DEGRADED" in states:
+        state = "DEGRADED"
+    elif "UNKNOWN" in states:
+        state = "UNKNOWN"
+    else:
+        state = "OK"
+
+    return {"state": state, "items": items}

psrsentinel-1.0.3/src/psrsentinel/checks/storage.py

@@ -0,0 +1,100 @@
+from psrsentinel.command import run_command
+
+
+def check_storage(check_config):
+    wanted = {}
+    for item in check_config.get("filesystems", []) or []:
+        wanted[item["mount"]] = item
+
+    result = run_command(
+        ["df", "-B1", "--output=target,size,used,avail,pcent"]
+    )
+    if result.returncode != 0:
+        return {
+            "state": "UNKNOWN",
+            "message": result.stderr or "Could not run df",
+            "filesystems": [],
+        }
+
+    observed = parse_df_output(result.stdout)
+    filesystems = []
+
+    for mount, thresholds in wanted.items():
+        fs = observed.get(mount)
+        if fs is None:
+            filesystems.append(
+                {
+                    "mount": mount,
+                    "state": "FAILED",
+                    "present": False,
+                    "message": "Expected filesystem is not present",
+                }
+            )
+            continue
+
+        warn = float(thresholds.get("warn_used_percent", 85))
+        fail = float(thresholds.get("fail_used_percent", 95))
+        used_percent = fs["used_percent"]
+
+        if used_percent >= fail:
+            state = "FAILED"
+            message = (
+                "Filesystem usage {0:.1f}% >= fail threshold {1:.1f}%".format(
+                    used_percent, fail
+                )
+            )
+        elif used_percent >= warn:
+            state = "DEGRADED"
+            message = (
+                "Filesystem usage {0:.1f}% >= warn threshold {1:.1f}%".format(
+                    used_percent, warn
+                )
+            )
+        else:
+            state = "OK"
+            message = None
+
+        fs = dict(fs)
+        fs.update(
+            {
+                "present": True,
+                "state": state,
+                "warn_used_percent": warn,
+                "fail_used_percent": fail,
+                "message": message,
+            }
+        )
+        filesystems.append(fs)
+
+    states = [item.get("state", "UNKNOWN") for item in filesystems]
+    if "FAILED" in states:
+        state = "FAILED"
+    elif "DEGRADED" in states:
+        state = "DEGRADED"
+    elif "UNKNOWN" in states:
+        state = "UNKNOWN"
+    else:
+        state = "OK"
+
+    return {"state": state, "filesystems": filesystems}
+
+
+def parse_df_output(output):
+    filesystems = {}
+    for line in output.splitlines()[1:]:
+        parts = line.split()
+        if len(parts) != 5:
+            continue
+        mount, size, used, avail, percent = parts
+        try:
+            used_percent = float(percent.rstrip("%"))
+            filesystems[mount] = {
+                "mount": mount,
+                "size_bytes": int(size),
+                "used_bytes": int(used),
+                "available_bytes": int(avail),
+                "used_percent": used_percent,
+            }
+        except ValueError:
+            continue
+    return filesystems

psrsentinel-1.0.3/src/psrsentinel/checks/time_sync.py

@@ -0,0 +1,56 @@
+from psrsentinel.command import run_command
+
+
+def check_time_sync(check_config):
+    required = bool(check_config.get("required", True))
+
+    result = run_command(
+        ["timedatectl", "show", "-p", "NTPSynchronized", "--value"]
+    )
+    if result.returncode == 0:
+        value = result.stdout.strip().lower()
+        synchronised = value == "yes"
+        return make_result(synchronised, required, None)
+
+    # Fallback for machines without systemd/timedatectl but with chrony.
+    chrony = run_command(["chronyc", "tracking"])
+    if chrony.returncode == 0:
+        # chronyc returns useful info only when it can talk to chronyd. Treat that
+        # as at least a successful diagnostic, and include the raw tracking text.
+        return {
+            "state": "OK",
+            "synchronised": True,
+            "required": required,
+            "method": "chronyc tracking",
+            "message": None,
+            "details": chrony.stdout,
+        }
+
+    return {
+        "state": "UNKNOWN",
+        "synchronised": None,
+        "required": required,
+        "message": result.stderr
+        or chrony.stderr
+        or "Could not check time synchronisation",
+    }
+
+
+def make_result(synchronised, required, details):
+    if synchronised:
+        state = "OK"
+        message = None
+    else:
+        state = "FAILED" if required else "DEGRADED"
+        message = "System clock is not NTP synchronised"
+
+    result = {
+        "state": state,
+        "synchronised": synchronised,
+        "required": required,
+        "method": "timedatectl",
+        "message": message,
+    }
+    if details is not None:
+        result["details"] = details
+    return result

psrsentinel-1.0.3/src/psrsentinel/command.py

@@ -0,0 +1,38 @@
+import subprocess
+
+
+class CommandResult(object):
+    def __init__(self, command, returncode, stdout, stderr):
+        self.command = command
+        self.returncode = returncode
+        self.stdout = stdout
+        self.stderr = stderr
+
+
+def run_command(args, timeout_seconds=8):
+    try:
+        proc = subprocess.Popen(
+            args,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            universal_newlines=True,
+        )
+        try:
+            stdout, stderr = proc.communicate(timeout=timeout_seconds)
+        except TypeError:
+            # Very old Python fallback. Python 3.6 supports timeout, but this
+            # keeps the helper boring if it is ever run under an older 3.x.
+            stdout, stderr = proc.communicate()
+        except subprocess.TimeoutExpired:
+            proc.kill()
+            stdout, stderr = proc.communicate()
+            return CommandResult(
+                args, 124, stdout.strip(), "Command timed out"
+            )
+
+        return CommandResult(
+            args, proc.returncode, stdout.strip(), stderr.strip()
+        )
+
+    except OSError as exc:
+        return CommandResult(args, 127, "", str(exc))

psrsentinel-1.0.3/src/psrsentinel/config.py

@@ -0,0 +1,25 @@
+import os
+
+import yaml
+
+
+def load_config(path):
+    with open(path, "r") as handle:
+        config = yaml.safe_load(handle)
+
+    if not isinstance(config, dict):
+        raise ValueError("Config file must contain a YAML mapping")
+
+    if "machines" not in config or not isinstance(config["machines"], list):
+        raise ValueError("Config file must contain a top-level machines list")
+
+    return config
+
+
+def get_api_key(api_config):
+    env_name = api_config.get("api_key_env")
+    if env_name:
+        value = os.environ.get(env_name)
+        if value:
+            return value
+    return api_config.get("api_key")

psrsentinel-1.0.3/src/psrsentinel/hostname.py

@@ -0,0 +1,44 @@
+import socket
+
+
+def get_local_names():
+    names = set()
+
+    for value in (socket.gethostname(), socket.getfqdn()):
+        if value:
+            names.add(value.lower())
+            names.add(value.split(".", 1)[0].lower())
+
+    return names
+
+
+def find_machine_config(config, hostname_override=None):
+    if hostname_override:
+        names = set(
+            [
+                hostname_override.lower(),
+                hostname_override.split(".", 1)[0].lower(),
+            ]
+        )
+    else:
+        names = get_local_names()
+
+    for machine in config.get("machines", []):
+        candidates = set()
+        hostname = machine.get("hostname")
+        if hostname:
+            candidates.add(hostname.lower())
+            candidates.add(hostname.split(".", 1)[0].lower())
+
+        for alias in machine.get("aliases", []) or []:
+            candidates.add(alias.lower())
+            candidates.add(alias.split(".", 1)[0].lower())
+
+        if names.intersection(candidates):
+            return machine
+
+    raise ValueError(
+        "No machine entry found for local hostname(s): {0}".format(
+            ", ".join(sorted(names))
+        )
+    )

psrsentinel-1.0.3/src/psrsentinel/scheduler.py

@@ -0,0 +1,34 @@
+import time
+
+
+class CheckSchedule(object):
+    def __init__(self):
+        self._last_run = {}
+
+    def should_run(self, check_name, interval_seconds):
+        previous = self._last_run.get(check_name)
+        now = time.monotonic()
+        if previous is None:
+            return True
+        return now - previous >= int(interval_seconds)
+
+    def mark_run(self, check_name):
+        self._last_run[check_name] = time.monotonic()
+
+
+def get_interval_seconds(check_config, intervals):
+    if "interval_seconds" in check_config:
+        return int(check_config["interval_seconds"])
+
+    interval_name = check_config.get("interval", "normal")
+    if interval_name not in intervals:
+        raise ValueError("Unknown interval name: {0}".format(interval_name))
+
+    return int(intervals[interval_name])
+
+
+def shortest_interval(intervals):
+    values = [int(value) for value in intervals.values()]
+    if not values:
+        return 60
+    return min(values)

psrsentinel-1.0.3/src/psrsentinel/state.py

@@ -0,0 +1,94 @@
+from datetime import datetime, timedelta
+
+try:
+    from datetime import timezone
+except ImportError:  # pragma: no cover
+    timezone = None
+
+
+STATE_ORDER = {
+    "OK": 0,
+    "UNKNOWN": 1,
+    "DEGRADED": 2,
+    "FAILED": 3,
+}
+
+PSRMON_STATE_MAP = {
+    "OK": "OK",
+    "DEGRADED": "WARNING",
+    "FAILED": "ERROR",
+    "UNKNOWN": "UNKNOWN",
+}
+
+
+def utc_now():
+    if timezone is not None:
+        return datetime.now(timezone.utc)
+    return datetime.utcnow()
+
+
+def utc_now_iso():
+    return utc_now().isoformat()
+
+
+def iso_after_seconds(seconds):
+    return (utc_now() + timedelta(seconds=int(seconds))).isoformat()
+
+
+def combine_states(states):
+    if not states:
+        return "UNKNOWN"
+    return max(states, key=lambda state: STATE_ORDER.get(state, 1))
+
+
+def collect_states(value):
+    states = []
+
+    if isinstance(value, dict):
+        state = value.get("state")
+        if isinstance(state, str):
+            states.append(state)
+        for nested in value.values():
+            states.extend(collect_states(nested))
+
+    elif isinstance(value, list):
+        for item in value:
+            states.extend(collect_states(item))
+
+    return states
+
+
+def map_to_psrmon_state(state):
+    return PSRMON_STATE_MAP.get(state, "UNKNOWN")
+
+
+def state_short_name(check_name):
+    names = {
+        "reachability": "alive",
+        "expected_processes": "proc",
+        "expected_services": "svc",
+        "expected_mounts": "mount",
+        "storage": "disk",
+        "memory": "mem",
+        "load": "load",
+        "time_sync": "time",
+    }
+    return names.get(check_name, check_name)
+
+
+def make_summary(checks):
+    if not checks:
+        return "no_checks=UNKNOWN"
+
+    parts = []
+    for check_name in sorted(checks.keys()):
+        check = checks[check_name]
+        state = "UNKNOWN"
+        if isinstance(check, dict):
+            state = check.get("state", "UNKNOWN")
+        parts.append(
+            "{0}={1}".format(
+                state_short_name(check_name), map_to_psrmon_state(state)
+            )
+        )
+    return " ".join(parts)

psrsentinel-1.0.3/src/psrsentinel.egg-info/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: psrsentinel
+Version: 1.0.3
+Summary: Jodrell bank pulsar server monitor
+Author: Benjamin Shaw
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: PyYAML<6.0,>=3.13; python_version < "3.10"
+Requires-Dist: PyYAML>=6.0; python_version >= "3.10"
+Requires-Dist: typing_extensions>=4.0; python_version < "3.8"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: tox; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"

psrsentinel-1.0.3/src/psrsentinel.egg-info/SOURCES.txt

@@ -0,0 +1,28 @@
+pyproject.toml
+src/psrsentinel/__init__.py
+src/psrsentinel/__main__.py
+src/psrsentinel/app.py
+src/psrsentinel/command.py
+src/psrsentinel/config.py
+src/psrsentinel/hostname.py
+src/psrsentinel/scheduler.py
+src/psrsentinel/state.py
+src/psrsentinel.egg-info/PKG-INFO
+src/psrsentinel.egg-info/SOURCES.txt
+src/psrsentinel.egg-info/dependency_links.txt
+src/psrsentinel.egg-info/entry_points.txt
+src/psrsentinel.egg-info/requires.txt
+src/psrsentinel.egg-info/top_level.txt
+src/psrsentinel/api/__init__.py
+src/psrsentinel/api/adapter.py
+src/psrsentinel/api/client.py
+src/psrsentinel/checks/__init__.py
+src/psrsentinel/checks/load.py
+src/psrsentinel/checks/memory.py
+src/psrsentinel/checks/mounts.py
+src/psrsentinel/checks/processes.py
+src/psrsentinel/checks/services.py
+src/psrsentinel/checks/storage.py
+src/psrsentinel/checks/time_sync.py
+tests/test_hostname.py
+tests/test_state.py

psrsentinel-1.0.3/src/psrsentinel.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

psrsentinel-1.0.3/src/psrsentinel.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+psrsentinel = psrsentinel.app:main

psrsentinel-1.0.3/src/psrsentinel.egg-info/requires.txt

@@ -0,0 +1,18 @@
+
+[:python_version < "3.10"]
+PyYAML<6.0,>=3.13
+
+[:python_version < "3.8"]
+typing_extensions>=4.0
+
+[:python_version >= "3.10"]
+PyYAML>=6.0
+
+[dev]
+pytest
+tox
+isort
+flake8
+black
+build
+twine

psrsentinel-1.0.3/src/psrsentinel.egg-info/top_level.txt

@@ -0,0 +1 @@
+psrsentinel

psrsentinel-1.0.3/tests/test_hostname.py

@@ -0,0 +1,11 @@
+from psrsentinel.hostname import find_machine_config
+
+
+def test_find_machine_by_hostname():
+    config = {"machines": [{"hostname": "ector"}]}
+    assert find_machine_config(config, "ector")["hostname"] == "ector"
+
+
+def test_find_machine_by_alias():
+    config = {"machines": [{"hostname": "ector", "aliases": ["ector.local"]}]}
+    assert find_machine_config(config, "ector.local")["hostname"] == "ector"

psrsentinel-1.0.3/tests/test_state.py

@@ -0,0 +1,26 @@
+from psrsentinel.state import combine_states, make_summary, map_to_psrmon_state
+
+
+def test_combine_states_ok():
+    assert combine_states(["OK", "OK"]) == "OK"
+
+
+def test_combine_states_degraded():
+    assert combine_states(["OK", "DEGRADED"]) == "DEGRADED"
+
+
+def test_combine_states_failed_wins():
+    assert combine_states(["OK", "DEGRADED", "FAILED"]) == "FAILED"
+
+
+def test_state_mapping():
+    assert map_to_psrmon_state("DEGRADED") == "WARNING"
+    assert map_to_psrmon_state("FAILED") == "ERROR"
+
+
+def test_make_summary():
+    summary = make_summary(
+        {"expected_processes": {"state": "OK"}, "storage": {"state": "FAILED"}}
+    )
+    assert "proc=OK" in summary
+    assert "disk=ERROR" in summary