Files
mtusi2026lab2/scripts/limits.py
T
ArtyomandClaude Opus 5.5 0ce7d6ecf0 Make storage and limits evidence reproducible from any clone
storage-evidence listed volumes by the name mtusi2026lab3, so a clone in
another directory recorded the volumes of the main stand; it now takes
the project name from docker compose config and filters by its label.
make limits wrote only the date, while every evidence file promises the
date and the commit in its first line; the commit is added.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01V1d3RLHNBBMA6UqBLLJv27
2026-10-29 23:12:55 +03:00

134 lines
5.6 KiB
Python

#!/usr/bin/env python3
import argparse
import json
import subprocess
import sys
import time
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
POLICY = {
"lb": {"secrets": [], "volumes": [], "networks": ["backend", "edge"], "ports": True},
"api": {
"secrets": ["cache_url", "cursor_secret", "database_url"],
"volumes": [],
"networks": ["backend"],
},
"migrate": {"secrets": ["database_url"], "volumes": [], "networks": ["backend"]},
"postgres": {"secrets": ["postgres_password"], "volumes": ["pgdata"], "networks": ["backend"]},
"valkey": {"secrets": ["valkey.conf"], "volumes": ["valkeydata"], "networks": ["backend"]},
"k6": {"secrets": [], "volumes": [], "networks": ["edge"]},
}
def run(*command):
done = subprocess.run(command, cwd=str(ROOT), capture_output=True, text=True, check=False)
return done.returncode, done.stdout.strip()
def declared(name, service, networks, problems):
limits = service.get("deploy", {}).get("resources", {}).get("limits", {})
secrets = sorted(s["source"] for s in service.get("secrets", []))
volumes = sorted(v["source"] for v in service.get("volumes", []) if v["type"] == "volume")
nets = sorted(service.get("networks", {}))
ports = [
f"{p.get('host_ip', '0.0.0.0')}:{p.get('published')}" for p in service.get("ports", [])
]
want = POLICY.get(name)
if want is None:
problems.append(f"{name}: service is not covered by the policy")
want = {"secrets": [], "volumes": [], "networks": []}
if not limits.get("cpus") or not limits.get("memory"):
problems.append(f"{name}: no CPU or memory limit")
if "container_name" in service:
problems.append(f"{name}: container_name prevents scaling")
for kind, actual in (("secrets", secrets), ("volumes", volumes), ("networks", nets)):
if actual != want[kind]:
problems.append(f"{name}: {kind} {actual}, policy {want[kind]}")
if ports and not want.get("ports"):
problems.append(f"{name}: publishes {ports} in bypass of the balancer")
if any(not port.startswith("127.0.0.1:") for port in ports):
problems.append(f"{name}: publishes {ports} beyond loopback")
if name == "api" and not service.get("read_only"):
problems.append("api: root filesystem is writable")
internal = [n for n in nets if networks.get(n, {}).get("internal")]
return [
name,
f"{limits.get('cpus', '-')}/{int(limits.get('memory') or 0) >> 20}MiB",
",".join(ports) or "-",
",".join(secrets) or "-",
",".join(volumes) or "-",
",".join(f"{n}{'(internal)' if n in internal else ''}" for n in nets),
str(service.get("read_only", False)).lower(),
]
def running(problems):
_, ids = run("docker", "compose", "ps", "-q")
template = (
'{{index .Config.Labels "com.docker.compose.service"}} {{.Config.Hostname}} '
"{{.HostConfig.NanoCpus}} {{.HostConfig.Memory}} {{json .HostConfig.PortBindings}}"
)
_, found = run("docker", "inspect", "-f", template, *ids.split())
rows = []
for line in found.splitlines():
service, host, cpus, memory, bindings = line.split(" ", 4)
published = [
f"{b['HostIp']}:{b['HostPort']}->{port}"
for port, items in (json.loads(bindings) or {}).items()
for b in items or []
]
if int(cpus) <= 0 or int(memory) <= 0:
problems.append(f"container {service}/{host}: no CPU or memory limit applied")
if published and service != "lb":
problems.append(f"container {service}/{host}: publishes {published}")
rows.append(
[service, host, f"{int(cpus) / 1e9:g}", f"{int(memory) >> 20}MiB", ",".join(published)]
)
return sorted(rows)
def table(header, rows):
widths = [max(len(str(r[i])) for r in [header, *rows]) for i in range(len(header))]
lines = [header, ["-" * w for w in widths], *rows]
return [" ".join(str(c).ljust(w) for c, w in zip(r, widths)).rstrip() for r in lines]
def main():
parser = argparse.ArgumentParser(description="limits, ports, secrets, volumes and networks")
parser.add_argument("--out", help="text report, written only after a complete check")
args = parser.parse_args()
problems = []
_, raw = run("docker", "compose", "--profile", "bench", "config", "--format", "json")
config = json.loads(raw)
services = [
declared(name, service, config.get("networks", {}), problems)
for name, service in sorted(config["services"].items())
]
containers = running(problems)
if not any(row[0] == "api" for row in containers):
problems.append("no running api replicas to inspect")
lines = [
f"date: {time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())} "
f"commit: {run('git', 'rev-parse', '--short', 'HEAD')[1]}",
"$ docker compose --profile bench config --format json (declared)",
*table(["service", "cpus/mem", "ports", "secrets", "volumes", "networks", "ro"], services),
"",
"$ docker inspect (running containers: hostname = X-Instance-Id, applied limits)",
*table(["service", "hostname", "cpus", "memory", "published"], containers),
"",
*(f"FAIL: {p}" for p in problems),
"PASS: limits, ports, secrets, volumes and networks match the policy"
if not problems
else f"FAIL: {len(problems)} violation(s)",
]
text = "\n".join(lines) + "\n"
if args.out:
Path(args.out).write_text(text)
print(text, end="")
return 1 if problems else 0
if __name__ == "__main__":
sys.exit(main())