import errno import fcntl import os import pathlib import sys import tempfile import unittest sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1])) from machine_load import memory from machine_load.slots import slot_count from machine_load import slots class SlotCount(unittest.TestCase): def test_one_slot_per_four_cpus_and_never_none(self): for cpus, slots in ((16, 4), (8, 2), (7, 1), (4, 1), (1, 1), (None, 1)): with self.subTest(cpus=cpus): self.assertEqual(slot_count(cpus), slots) class MemoryShare(unittest.TestCase): def test_has_room_from_a_quarter_of_memory_available(self): self.assertFalse(memory.Memory(available=3, total=16).has_room()) self.assertTrue(memory.Memory(available=4, total=16).has_room()) def test_reads_available_and_total_memory_from_meminfo(self): meminfo = "MemTotal: 16387072 kB\nMemFree: 981236 kB\nMemAvailable: 4096000 kB\n" self.assertEqual(memory.parsed(meminfo), memory.Memory(available=4096000, total=16387072)) def test_reads_nothing_from_a_meminfo_missing_a_figure_or_holding_a_bad_one(self): for unread in ("MemTotal: 16 kB\n", "MemTotal: x kB\nMemAvailable: 1 kB\n", ""): with self.subTest(unread=unread): self.assertIsNone(memory.parsed(unread)) def test_reads_a_meminfo_file_and_none_where_it_cannot(self): with tempfile.TemporaryDirectory() as temp: meminfo = pathlib.Path(temp, "meminfo") meminfo.write_text("MemTotal: 8 kB\nMemAvailable: 2 kB\n") self.assertEqual(memory.read_memory(meminfo), memory.Memory(available=2, total=8)) self.assertIsNone(memory.read_memory(pathlib.Path(temp, "gone"))) class SlotShare(unittest.TestCase): def test_splits_the_three_quarters_a_worker_leaves_evenly_across_the_slots_in_mib(self): self.assertEqual(memory.Memory(available=0, total=32 * 1024 * 1024).slot_share(4), 6144) self.assertEqual(memory.Memory(available=0, total=8000000).slot_share(2), 2929) class SlotFolder(unittest.TestCase): def test_every_session_shares_the_slots_under_the_users_state_folder(self): self.assertEqual(slots.slot_folder({}, pathlib.Path.home()), pathlib.Path.home() / ".local" / "state" / "run-heavy") self.assertEqual(slots.slot_folder({"XDG_STATE_HOME": "/s"}, pathlib.Path.home()), pathlib.Path("/s/run-heavy")) class TakenSlot(unittest.TestCase): def test_a_lock_that_fails_for_another_reason_than_a_holder_closes_its_file_and_raises(self): locked = [] def lock(fd, operation): locked.append(fd) raise OSError(errno.ENOLCK, "No locks available") with tempfile.TemporaryDirectory() as folder: with self.assertRaises(OSError): slots.taken_slot(pathlib.Path(folder), 2, lock) self.assertEqual(len(locked), 1) with self.assertRaises(OSError) as closed: os.fstat(locked[0]) self.assertEqual(closed.exception.errno, errno.EBADF) class WaitedSlot(unittest.TestCase): def test_waits_while_every_slot_is_held_saying_so_once_then_takes_the_freed_one(self): with tempfile.TemporaryDirectory() as folder: held = [open(pathlib.Path(folder, f"slot-{slot}"), "a") for slot in range(2)] for file in held: fcntl.flock(file, fcntl.LOCK_EX | fcntl.LOCK_NB) said, slept = [], [] def sleep(seconds): slept.append(seconds) if len(slept) == 2: held[1].close() slot, fd = slots.waited_slot(pathlib.Path(folder), 2, lambda: said.append(True), sleep, fcntl.flock) os.close(fd) held[0].close() self.assertEqual((slot, said, slept), (1, [True], [slots.POLL_SECONDS] * 2)) def test_takes_a_free_slot_at_once(self): with tempfile.TemporaryDirectory() as folder: slot, fd = slots.waited_slot(pathlib.Path(folder), 2, lambda: self.fail("said it waits"), lambda seconds: self.fail("slept"), fcntl.flock) os.close(fd) self.assertEqual(slot, 0) if __name__ == "__main__": unittest.main()