146 lines
6.3 KiB
Python
146 lines
6.3 KiB
Python
import contextlib
|
|
import fcntl
|
|
import os
|
|
import pathlib
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import unittest
|
|
|
|
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
|
|
|
from run_heavy import main
|
|
from machine_load.memory import read_memory
|
|
from machine_load.slots import slot_count, usable_cpus
|
|
|
|
TOOL = pathlib.Path(__file__).resolve().parents[1] / "run-heavy"
|
|
|
|
|
|
class RunHeavy(unittest.TestCase):
|
|
def setUp(self):
|
|
state = tempfile.TemporaryDirectory()
|
|
self.addCleanup(state.cleanup)
|
|
self.env = {**os.environ, "XDG_STATE_HOME": state.name}
|
|
self.env.pop(main.HELD, None)
|
|
self.slots = pathlib.Path(state.name) / "run-heavy"
|
|
|
|
def run_tool(self, *args: str, env=None) -> subprocess.CompletedProcess[str]:
|
|
return subprocess.run([sys.executable, str(TOOL), *args], capture_output=True, text=True, env=env or self.env, timeout=30)
|
|
|
|
def start_tool(self, *args: str, env=None) -> subprocess.Popen[str]:
|
|
tool = subprocess.Popen([sys.executable, str(TOOL), *args], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, env=env or self.env)
|
|
self.addCleanup(tool.kill)
|
|
return tool
|
|
|
|
@contextlib.contextmanager
|
|
def every_slot_held(self):
|
|
self.slots.mkdir(parents=True, exist_ok=True)
|
|
with contextlib.ExitStack() as held:
|
|
for slot in range(slot_count(usable_cpus())):
|
|
file = held.enter_context(open(self.slots / f"slot-{slot}", "a"))
|
|
fcntl.flock(file, fcntl.LOCK_EX | fcntl.LOCK_NB)
|
|
yield
|
|
|
|
def free_slots(self) -> int:
|
|
free = 0
|
|
for slot in range(slot_count(usable_cpus())):
|
|
with open(self.slots / f"slot-{slot}", "a") as file:
|
|
try:
|
|
fcntl.flock(file, fcntl.LOCK_EX | fcntl.LOCK_NB)
|
|
free += 1
|
|
except BlockingIOError:
|
|
pass
|
|
return free
|
|
|
|
def test_runs_the_command_and_exits_with_its_code(self):
|
|
result = self.run_tool("sh", "-c", "echo out; echo err >&2; exit 3")
|
|
self.assertEqual((result.returncode, result.stdout, result.stderr), (3, "out\n", "err\n"))
|
|
|
|
def test_holds_a_slot_while_the_command_runs_and_frees_it_after(self):
|
|
tool = self.start_tool("sh", "-c", "echo started; read line")
|
|
self.assertEqual(tool.stdout.readline(), "started\n")
|
|
self.assertEqual(self.free_slots(), slot_count(usable_cpus()) - 1)
|
|
tool.communicate("\n", timeout=30)
|
|
self.assertEqual(self.free_slots(), slot_count(usable_cpus()))
|
|
|
|
def test_a_command_inside_a_held_slot_runs_at_once(self):
|
|
with self.every_slot_held():
|
|
result = self.run_tool("echo", "nested", env={**self.env, main.HELD: "0"})
|
|
self.assertEqual((result.returncode, result.stdout), (0, "nested\n"))
|
|
|
|
def test_exits_125_saying_why_where_the_slot_folder_cannot_be_made(self):
|
|
with tempfile.NamedTemporaryFile() as state:
|
|
result = self.run_tool("echo", "ran", env={**self.env, "XDG_STATE_HOME": state.name})
|
|
self.assertEqual((result.returncode, result.stdout), (125, ""))
|
|
self.assertIn(state.name, result.stderr)
|
|
|
|
def test_a_command_not_found_exits_127_and_one_that_cannot_run_126_saying_why(self):
|
|
missing = self.run_tool("no-such-command-anywhere")
|
|
self.assertEqual((missing.returncode, missing.stdout), (127, ""))
|
|
self.assertIn("no-such-command-anywhere", missing.stderr)
|
|
with tempfile.NamedTemporaryFile(suffix=".sh") as unrunnable:
|
|
denied = self.run_tool(unrunnable.name)
|
|
self.assertEqual((denied.returncode, denied.stdout), (126, ""))
|
|
self.assertIn(unrunnable.name, denied.stderr)
|
|
|
|
def fake_docker(self) -> dict[str, str]:
|
|
"""An environment whose PATH finds, ahead of any real one, a docker that prints the arguments it was given."""
|
|
folder = tempfile.TemporaryDirectory()
|
|
self.addCleanup(folder.cleanup)
|
|
docker = pathlib.Path(folder.name) / "docker"
|
|
docker.write_text("#!/bin/sh\necho \"$@\"\n")
|
|
docker.chmod(0o755)
|
|
return {**self.env, "PATH": f"{folder.name}:{self.env['PATH']}"}
|
|
|
|
def test_a_docker_run_without_limits_gets_three_quarters_of_the_memory_split_across_the_slots(self):
|
|
memory = read_memory()
|
|
assert memory is not None, "this test needs MemTotal and MemAvailable from /proc/meminfo: run it on Linux"
|
|
share = f"{memory.total * 3 // 4 // slot_count(usable_cpus()) // 1024}m"
|
|
result = self.run_tool("docker", "run", "--rm", "img", "true", env=self.fake_docker())
|
|
self.assertEqual((result.returncode, result.stdout), (0, f"run --memory {share} --memory-swap {share} --rm img true\n"))
|
|
|
|
def test_a_docker_call_with_its_own_limits_or_that_starts_no_container_is_passed_on_unchanged(self):
|
|
env = self.fake_docker()
|
|
for args in [["run", "-m", "40g", "--memory-swap", "40g", "img"], ["ps", "-a"], ["build", "."]]:
|
|
with self.subTest(args):
|
|
result = self.run_tool("docker", *args, env=env)
|
|
self.assertEqual((result.returncode, result.stdout), (0, " ".join(args) + "\n"))
|
|
|
|
def test_a_command_on_a_machine_without_docker_finds_none(self):
|
|
folder = tempfile.TemporaryDirectory()
|
|
self.addCleanup(folder.cleanup)
|
|
(pathlib.Path(folder.name) / "python3").symlink_to(sys.executable)
|
|
(pathlib.Path(folder.name) / "sh").symlink_to("/bin/sh")
|
|
result = self.run_tool("sh", "-c", "command -v docker || echo none", env={**self.env, "PATH": folder.name})
|
|
self.assertEqual((result.returncode, result.stdout), (0, "none\n"))
|
|
|
|
def test_the_capped_docker_passes_a_call_on_unchanged_without_a_share(self):
|
|
env = self.fake_docker()
|
|
env.pop("RUN_HEAVY_MEMORY", None)
|
|
shim = pathlib.Path(TOOL).parent / "run_heavy" / "path_entry" / "docker"
|
|
result = subprocess.run([str(shim), "run", "img"], capture_output=True, text=True, env=env, timeout=30)
|
|
self.assertEqual((result.returncode, result.stdout), (0, "run img\n"))
|
|
|
|
def test_no_cap_where_the_memory_is_unknown(self):
|
|
self.assertEqual(main.capping(None, 4, self.fake_docker()), {})
|
|
|
|
def test_a_capped_docker_that_finds_no_docker_exits_127_saying_so(self):
|
|
folder = tempfile.TemporaryDirectory()
|
|
self.addCleanup(folder.cleanup)
|
|
(pathlib.Path(folder.name) / "python3").symlink_to(sys.executable)
|
|
result = self.run_tool("docker", "ps", env={**self.env, "PATH": folder.name})
|
|
self.assertEqual((result.returncode, result.stdout), (127, ""))
|
|
self.assertIn("docker", result.stderr)
|
|
|
|
def test_no_command_exits_125_with_the_usage_and_help_exits_0(self):
|
|
bare = self.run_tool()
|
|
self.assertEqual((bare.returncode, bare.stdout), (125, ""))
|
|
self.assertIn("usage: run-heavy <command>", bare.stderr)
|
|
helped = self.run_tool("--help")
|
|
self.assertEqual(helped.returncode, 0)
|
|
self.assertIn("usage: run-heavy <command>", helped.stdout)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|