"""Real login1 sleep handshakes; run with dbus-run-session and python3-gi.""" import os from pathlib import Path import subprocess import signal import tempfile import time import unittest try: import gi gi.require_version("Gio", "2.0") from gi.repository import Gio, GLib except ImportError: Gio = GLib = None SCRIPT = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin/droiddeck-login1" NAME = "org.freedesktop.login1" ROOT = "/org/freedesktop/login1" IFACE = NAME + ".Manager" @unittest.skipUnless(Gio and os.environ.get("DBUS_SESSION_BUS_ADDRESS"), "requires dbus-run-session and PyGObject") class SleepHandshakeTest(unittest.TestCase): ARGS = [] AGENT_EXIT = None def setUp(self): self.directory = tempfile.TemporaryDirectory() self.dir = Path(self.directory.name) self.signals = [] self.bus = Gio.DBusConnection.new_for_address_sync( os.environ["DBUS_SESSION_BUS_ADDRESS"], Gio.DBusConnectionFlags.AUTHENTICATION_CLIENT | Gio.DBusConnectionFlags.MESSAGE_BUS_CONNECTION, None, None) self.subscription = self.bus.signal_subscribe( NAME, IFACE, "PrepareForSleep", ROOT, None, Gio.DBusSignalFlags.NONE, lambda bus, sender, path, interface, name, body: self.signals.append(body.unpack()[0])) env = dict(os.environ, BL_LAUNCH_DIR=str(self.dir), DBUS_SYSTEM_BUS_ADDRESS=os.environ["DBUS_SESSION_BUS_ADDRESS"]) script = SCRIPT if self.AGENT_EXIT is not None: bin_dir = self.dir / "bin" bin_dir.mkdir() script = bin_dir / SCRIPT.name script.write_text(SCRIPT.read_text()) agent = bin_dir / "droiddeck-agent" agent.write_text("#!/bin/sh\necho \"$@\" >> \"%s\"\nexit %d\n" % (self.dir / "agent-calls", self.AGENT_EXIT)) agent.chmod(0o755) self.process = subprocess.Popen(["/usr/bin/python3", str(script), *self.ARGS], env=env, stdout=subprocess.DEVNULL) self.wait_for(lambda: (self.dir / "steam-sleep-ready").exists()) def tearDown(self): os.kill(self.process.pid, signal.SIGCONT) self.process.terminate() self.process.wait(timeout=5) self.bus.signal_unsubscribe(self.subscription) self.bus.close_sync(None) self.directory.cleanup() def wait_for(self, condition, timeout=8): deadline = time.monotonic() + timeout while not condition(): while GLib.MainContext.default().pending(): GLib.MainContext.default().iteration(False) if time.monotonic() >= deadline: self.fail("timed out waiting for login1") time.sleep(0.01) def call(self, interface, method, args=None): return self.bus.call_sync(NAME, ROOT, interface, method, args, None, Gio.DBusCallFlags.NONE, 2000, None).unpack() def preparing(self): return self.call("org.freedesktop.DBus.Properties", "Get", GLib.Variant("(ss)", (IFACE, "PreparingForSleep")))[0] def suspend(self): (self.dir / "steam-sleep").unlink(missing_ok=True) self.call(IFACE, "Suspend", GLib.Variant("(b)", (True,))) self.wait_for(lambda: (self.dir / "steam-sleep").exists()) self.wait_for(lambda: self.signals == [True]) return (self.dir / "steam-sleep").read_text().strip() def state(self, token, state): staged = self.dir / "steam-sleep-state.tmp" staged.write_text(token + ":" + state + "\n") staged.replace(self.dir / "steam-sleep-state") def test_resume_and_second_sleep(self): self.assertEqual(self.call(IFACE, "CanSuspend"), ("yes",)) token = self.suspend() self.assertTrue(self.preparing()) self.state(token, "paused") self.state("0" * 32, "awake") time.sleep(0.1) self.assertTrue(self.preparing()) self.state(token, "awake") self.wait_for(lambda: self.signals == [True, False]) self.assertFalse(self.preparing()) self.signals.clear() second = self.suspend() self.assertNotEqual(token, second) self.state(second, "awake") self.wait_for(lambda: self.signals == [True, False]) def test_missing_host_recovers(self): self.suspend() self.wait_for(lambda: self.signals == [True, False]) self.assertFalse(self.preparing()) self.assertFalse((self.dir / "steam-sleep").exists()) def test_wake_after_service_was_frozen_past_ack_timeout(self): token = self.suspend() self.state(token, "paused") os.kill(self.process.pid, signal.SIGSTOP) time.sleep(6) self.state(token, "awake") os.kill(self.process.pid, signal.SIGCONT) self.wait_for(lambda: self.signals == [True, False]) self.assertFalse(self.preparing()) def test_suspend_after_service_was_frozen(self): os.kill(self.process.pid, signal.SIGSTOP) time.sleep(0.1) os.kill(self.process.pid, signal.SIGCONT) token = self.suspend() self.state(token, "awake") self.wait_for(lambda: self.signals == [True, False]) self.assertFalse(self.preparing()) def test_legacy_upower_suspend_uses_the_same_wake_handshake(self): self.bus.call_sync("org.freedesktop.UPower", "/org/freedesktop/UPower", "org.freedesktop.UPower", "Suspend", None, None, Gio.DBusCallFlags.NONE, 2000, None) self.wait_for(lambda: (self.dir / "steam-sleep").exists()) self.wait_for(lambda: self.signals == [True]) token = (self.dir / "steam-sleep").read_text().strip() self.assertTrue(self.preparing()) self.state(token, "awake") self.wait_for(lambda: self.signals == [True, False]) self.assertFalse(self.preparing()) def request_wake(self): staged = self.dir / "steam-wake.tmp" staged.write_text("wake\n") staged.replace(self.dir / "steam-wake") def request_native(self, token="1" * 32): staged = self.dir / "steam-native-sleep.tmp" staged.write_text(token + "\n") staged.replace(self.dir / "steam-native-sleep") return token def test_native_sleep_prepares_before_host_can_freeze(self): started = time.monotonic() token = self.request_native() self.wait_for(lambda: self.signals == [True]) self.assertTrue(self.preparing()) self.assertFalse((self.dir / "steam-native-ready").exists()) self.assertFalse((self.dir / "steam-sleep").exists()) self.wait_for(lambda: (self.dir / "steam-native-ready").exists()) self.assertGreaterEqual(time.monotonic() - started, 1.4) self.assertEqual((self.dir / "steam-native-ready").read_text().strip(), token) self.state(token, "paused") self.state(token, "awake") self.wait_for(lambda: self.signals == [True, False]) self.assertFalse(self.preparing()) def test_return_during_native_preparation_cancels_late_pause(self): token = self.request_native() self.wait_for(lambda: self.signals == [True]) self.state(token, "awake") self.wait_for(lambda: self.signals == [True, False]) time.sleep(1.7) self.assertFalse((self.dir / "steam-native-ready").exists()) self.assertFalse(self.preparing()) def test_native_request_cancelled_before_helper_reads_it(self): os.kill(self.process.pid, signal.SIGSTOP) token = self.request_native() self.state(token, "awake") os.kill(self.process.pid, signal.SIGCONT) self.wait_for(lambda: not (self.dir / "steam-native-sleep").exists()) time.sleep(1.7) self.assertFalse((self.dir / "steam-native-ready").exists()) self.assertFalse(self.preparing()) self.assertEqual(self.signals, []) def test_second_native_sleep_cannot_receive_first_preparation_callback(self): first = self.request_native() self.wait_for(lambda: self.signals == [True]) self.state(first, "awake") self.wait_for(lambda: self.signals == [True, False]) self.signals.clear() second = self.request_native("2" * 32) self.wait_for(lambda: (self.dir / "steam-native-ready").exists()) self.assertEqual((self.dir / "steam-native-ready").read_text().strip(), second) self.state(second, "awake") self.wait_for(lambda: self.signals == [True, False]) def test_native_sleep_with_missing_host_recovers(self): self.request_native() self.wait_for(lambda: self.signals == [True, False], timeout=9) self.assertFalse(self.preparing()) self.assertFalse((self.dir / "steam-native-ready").exists()) def test_host_resume_recovers_without_a_sleep_request(self): self.assertFalse(self.preparing()) self.request_wake() self.wait_for(lambda: self.signals == [True, False]) self.assertFalse((self.dir / "steam-wake").exists()) def test_host_wake_survives_frozen_service(self): token = self.suspend() self.state(token, "paused") os.kill(self.process.pid, signal.SIGSTOP) self.request_wake() os.kill(self.process.pid, signal.SIGCONT) self.wait_for(lambda: self.signals == [True, False]) self.assertFalse(self.preparing()) def test_failed_pause_recovers_and_duplicate_is_rejected(self): token = self.suspend() with self.assertRaises(GLib.Error): self.call(IFACE, "Suspend", GLib.Variant("(b)", (True,))) self.state(token, "awake") self.wait_for(lambda: self.signals == [True, False]) with self.assertRaises(GLib.Error): self.call(IFACE, "PowerOff", GLib.Variant("(b)", (True,))) class FakeAgentCase(unittest.TestCase): ARGS = [] setUp = SleepHandshakeTest.setUp tearDown = SleepHandshakeTest.tearDown wait_for = SleepHandshakeTest.wait_for call = SleepHandshakeTest.call suspend = SleepHandshakeTest.suspend state = SleepHandshakeTest.state request_wake = SleepHandshakeTest.request_wake request_native = SleepHandshakeTest.request_native def asked(self): path = self.dir / "agent-calls" return path.read_text().split() if path.exists() else [] @unittest.skipUnless(Gio and os.environ.get("DBUS_SESSION_BUS_ADDRESS"), "requires dbus-run-session and PyGObject") class AwakeSteamTest(FakeAgentCase): AGENT_EXIT = 5 def test_resuming_an_awake_steam_sends_no_sleep_wake_pair(self): self.request_wake() self.wait_for(lambda: self.asked()) deadline = time.monotonic() + 1.5 while time.monotonic() < deadline: self.wait_for(lambda: True) time.sleep(0.05) self.assertEqual([], self.signals) self.assertEqual(["--steam-asleep"], self.asked()) def test_a_pending_sleep_still_wakes_without_asking_steam(self): token = self.suspend() self.state(token, "paused") self.request_wake() self.wait_for(lambda: self.signals == [True, False]) self.assertNotIn("--steam-asleep", self.asked()) @unittest.skipUnless(Gio and os.environ.get("DBUS_SESSION_BUS_ADDRESS"), "requires dbus-run-session and PyGObject") class AsleepSteamTest(FakeAgentCase): AGENT_EXIT = 0 def test_resuming_a_sleeping_steam_replays_the_pair(self): self.request_wake() self.wait_for(lambda: self.signals == [True, False]) self.assertEqual(["--steam-asleep"], self.asked()) def test_steam_sleep_request_holds_idle_sleep_before_the_host_pauses(self): token = self.suspend() self.assertEqual(["--steam-idle-inhibit", "on"], self.asked()) self.state(token, "paused") self.state(token, "awake") self.wait_for(lambda: self.signals == [True, False]) self.wait_for(lambda: self.asked()[-1:] == ["off"]) self.assertEqual(["--steam-idle-inhibit", "on", "--steam-idle-suspend-seconds", "--steam-idle-inhibit", "off"], self.asked()) def test_idle_pause_holds_idle_sleep_without_a_sleep_wake_pair(self): token = self.request_native("2" * 32 + " idle").split()[0] self.wait_for(lambda: (self.dir / "steam-native-ready").exists()) self.assertEqual(token, (self.dir / "steam-native-ready").read_text().strip()) self.assertEqual(["--steam-idle-inhibit", "on"], self.asked()) self.state(token, "paused") self.state(token, "awake") self.wait_for(lambda: self.asked()[-1:] == ["off"]) self.assertEqual([], self.signals) self.assertEqual(["--steam-idle-inhibit", "on", "--steam-idle-suspend-seconds", "--steam-idle-inhibit", "off"], self.asked()) def test_a_failed_release_is_tried_again(self): failed = self.dir / "release-failed" (self.dir / "bin/droiddeck-agent").write_text( "#!/bin/sh\necho \"$@\" >> \"%s\"\n" "if [ \"$2\" = off ] && [ ! -e \"%s\" ]; then : > \"%s\"; exit 1; fi\nexit 0\n" % (self.dir / "agent-calls", failed, failed)) token = self.suspend() self.state(token, "paused") self.state(token, "awake") self.wait_for(lambda: self.asked().count("off") == 2) time.sleep(2.5) self.assertEqual(["--steam-idle-inhibit", "on", "--steam-idle-suspend-seconds", "--steam-idle-inhibit", "off", "--steam-idle-inhibit", "off"], self.asked()) def test_a_hold_steam_did_not_confirm_is_still_released(self): (self.dir / "bin/droiddeck-agent").write_text( "#!/bin/sh\necho \"$@\" >> \"%s\"\n[ \"$2\" = on ] && exit 1\nexit 0\n" % (self.dir / "agent-calls")) token = self.suspend() self.state(token, "paused") self.state(token, "awake") self.wait_for(lambda: self.signals == [True, False]) self.wait_for(lambda: self.asked()[-1:] == ["off"]) self.assertEqual(["--steam-idle-inhibit", "on", "--steam-idle-suspend-seconds", "--steam-idle-inhibit", "off"], self.asked()) class WithNetworkManagerTest(SleepHandshakeTest): ARGS = ["--with-netmanager"] def owner(self, name): return self.bus.call_sync("org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus", "GetConnectionUnixProcessID", GLib.Variant("(s)", (name,)), None, Gio.DBusCallFlags.NONE, 2000, None).unpack()[0] def test_one_process_owns_login1_and_networkmanager(self): self.wait_for(lambda: self.bus.call_sync( "org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus", "NameHasOwner", GLib.Variant("(s)", ("org.freedesktop.NetworkManager",)), None, Gio.DBusCallFlags.NONE, 2000, None).unpack()[0]) self.assertEqual(self.owner("org.freedesktop.NetworkManager"), self.process.pid) self.assertEqual(self.owner(NAME), self.process.pid) if __name__ == "__main__": unittest.main()