| """H8: the inhibition simulator agrees with a real Alertmanager process on the generated case shapes. |
| |
| Marked `am`: needs the alertmanager binary (AF_ALERTMANAGER, PATH, or ../../vendor/bin/alertmanager). |
| """ |
|
|
| import json |
| import os |
| import shutil |
| import socket |
| import subprocess |
| import tempfile |
| import time |
| import urllib.request |
|
|
| import pytest |
| import yaml |
|
|
| from alertforge import routing |
| from alertforge.grader.amcheck import inhibited |
|
|
| from conftest import VENDOR_BIN |
|
|
| AM = os.environ.get("AF_ALERTMANAGER") or shutil.which("alertmanager") or os.path.join(VENDOR_BIN, "alertmanager") |
| pytestmark = [pytest.mark.am, pytest.mark.skipif(not os.path.exists(AM), reason="alertmanager binary not found")] |
|
|
| RULES = { |
| "oracle": routing.inhibit_rule("SvcDown", ["BurnFast", "HighErrorRatio"]), |
| "R05": {k: v for k, v in routing.inhibit_rule("SvcDown", ["BurnFast", "HighErrorRatio"]).items() if k != "equal"}, |
| "legacy": {"source_match": {"alertname": "SvcDown"}, "target_match_re": {"alertname": "Burn.*"}, "equal": ["service"]}, |
| } |
|
|
|
|
| def _port() -> int: |
| s = socket.socket() |
| s.bind(("127.0.0.1", 0)) |
| p = s.getsockname()[1] |
| s.close() |
| return p |
|
|
|
|
| def _real(rule: dict, source: dict | None, target: dict) -> bool: |
| d = tempfile.mkdtemp() |
| cfg = {"route": {"receiver": "null"}, "receivers": [{"name": "null"}], "inhibit_rules": [rule]} |
| with open(os.path.join(d, "am.yml"), "w") as fh: |
| yaml.safe_dump(cfg, fh) |
| port, cport = _port(), _port() |
| proc = subprocess.Popen([AM, f"--config.file={d}/am.yml", f"--storage.path={d}/data", |
| f"--web.listen-address=127.0.0.1:{port}", f"--cluster.listen-address=", |
| f"--cluster.advertise-address=127.0.0.1:{cport}"], |
| stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) |
| base = f"http://127.0.0.1:{port}/api/v2" |
| try: |
| for _ in range(100): |
| try: |
| urllib.request.urlopen(f"{base}/status", timeout=1) |
| break |
| except OSError: |
| time.sleep(0.1) |
| alerts = [{"labels": a} for a in ([source] if source else []) + [target]] |
| req = urllib.request.Request(f"{base}/alerts", json.dumps(alerts).encode(), {"Content-Type": "application/json"}) |
| urllib.request.urlopen(req, timeout=5) |
| want = target["alertname"] |
| for _ in range(30): |
| time.sleep(0.2) |
| got = json.load(urllib.request.urlopen(f"{base}/alerts", timeout=5)) |
| tgt = [a for a in got if a["labels"].get("alertname") == want and a["labels"] == target] |
| if tgt and (tgt[0]["status"]["inhibitedBy"] or len(got) == len(alerts)): |
| return bool(tgt[0]["status"]["inhibitedBy"]) |
| return False |
| finally: |
| proc.terminate() |
| proc.wait(timeout=10) |
| shutil.rmtree(d, ignore_errors=True) |
|
|
|
|
| CASES = routing.inhibit_cases("SvcDown", ["BurnFast", "HighErrorRatio"], "chat-gw", "orders-api", "payments", "PodMemoryHigh") |
|
|
|
|
| @pytest.mark.parametrize("rule_name", sorted(RULES)) |
| @pytest.mark.parametrize("i", range(len(CASES))) |
| def test_simulator_matches_alertmanager(rule_name, i): |
| c = CASES[i] |
| rule = RULES[rule_name] |
| sim = inhibited({"inhibit_rules": [rule]}, c["source"], c["target"]) |
| assert sim == _real(rule, c["source"], c["target"]) |
|
|
