From 7e4a837e430701bf6e489098c9d3a64e39f9cdb4 Mon Sep 17 00:00:00 2001 From: Ali Mirjamali Date: Thu, 28 Aug 2025 16:17:40 +0330 Subject: [PATCH 1/5] Initialize asyncio event loop before using it Python 3.14 (in Fedora 43) throws RunetimeError if event loop is not initialized before using it. Resolves: QubesOS/qubes-issues#10188 --- doc/qubes-events.rst | 6 +++--- qubes/backup.py | 2 +- qubes/tests/__init__.py | 3 ++- qubes/tests/api_admin.py | 15 ++++++++++----- qubes/tests/api_internal.py | 3 ++- qubes/tests/api_misc.py | 3 ++- qubes/tests/devices_block.py | 21 ++++++++------------- qubes/tests/events.py | 3 ++- qubes/tests/integ/backupcompatibility.py | 2 +- qubes/tools/qubes_create.py | 2 +- qubes/tools/qubesd.py | 3 ++- qubes/tools/qubesd_query.py | 3 ++- qubes/vm/__init__.py | 2 +- 13 files changed, 37 insertions(+), 31 deletions(-) diff --git a/doc/qubes-events.rst b/doc/qubes-events.rst index d341c2912..0e564d516 100644 --- a/doc/qubes-events.rst +++ b/doc/qubes-events.rst @@ -177,8 +177,7 @@ handler (a coroutine) for synchronous event (the one fired with o = MyClass() o.events_enabled = True - loop = asyncio.get_event_loop() - loop.run_until_complete(o.fire_event_async('event1')) + asyncio.run(o.fire_event_async('event1')) Asynchronous event handlers can also return value - but only a collection, not yield individual values (because of python limitation): @@ -207,7 +206,8 @@ yield individual values (because of python limitation): o = MyClass() o.events_enabled = True - loop = asyncio.get_event_loop() + loop = asyncio.new_event_loop() + asyncio.set_event_loop(loop) # returns ['sync result', 'result1', 'result2', 'result3', 'result4'], # possibly not in order effects = loop.run_until_complete(o.fire_event_async('event1')) diff --git a/qubes/backup.py b/qubes/backup.py index 6335b212b..9aa69c39a 100644 --- a/qubes/backup.py +++ b/qubes/backup.py @@ -256,7 +256,7 @@ class Backup: >>> } >>> backup_op = Backup(app, vms, exclude_vms, **options) >>> print(backup_op.get_backup_summary()) - >>> asyncio.get_event_loop().run_until_complete(backup_op.backup_do()) + >>> asyncio.run(backup_op.backup_do()) See attributes of this object for all available options. diff --git a/qubes/tests/__init__.py b/qubes/tests/__init__.py index db69003e3..6bfb4c7af 100644 --- a/qubes/tests/__init__.py +++ b/qubes/tests/__init__.py @@ -513,7 +513,8 @@ def setUp(self): super().setUp() self.addCleanup(self.cleanup_gc) - self.loop = asyncio.get_event_loop() + self.loop = asyncio.new_event_loop() + asyncio.set_event_loop(self.loop) self.addCleanup(self.cleanup_loop) self.kernel_validator_original = qubes.app.validate_kernel diff --git a/qubes/tests/api_admin.py b/qubes/tests/api_admin.py index b31dc4abe..a38d99154 100644 --- a/qubes/tests/api_admin.py +++ b/qubes/tests/api_admin.py @@ -145,7 +145,8 @@ def call_mgmt_func(self, method, dest, arg=b"", payload=b""): self.app, b"dom0", method, dest, arg ) - loop = asyncio.get_event_loop() + loop = asyncio.new_event_loop() + asyncio.set_event_loop(loop) response = loop.run_until_complete( mgmt_obj.execute(untrusted_payload=payload) ) @@ -158,7 +159,8 @@ def call_internal_mgmt_func(self, method, dest, arg=b"", payload=b""): mgmt_obj = qubes.api.internal.QubesInternalAPI( self.app, b"dom0", method, dest, arg ) - loop = asyncio.get_event_loop() + loop = asyncio.new_event_loop() + asyncio.set_event_loop(loop) response = loop.run_until_complete( mgmt_obj.execute(untrusted_payload=payload) ) @@ -230,7 +232,8 @@ def test_002_vm_list_filter(self): mgmt_obj = qubes.api.admin.QubesAdminAPI( self.app, b"test-vm1", b"admin.vm.List", b"dom0", b"" ) - loop = asyncio.get_event_loop() + loop = asyncio.new_event_loop() + asyncio.set_event_loop(loop) value = loop.run_until_complete( mgmt_obj.execute(untrusted_payload=b"") ) @@ -3762,7 +3765,8 @@ def __init__(self, name): def name(self): return self._name - loop = asyncio.get_event_loop() + loop = asyncio.new_event_loop() + asyncio.set_event_loop(loop) self.app.vmm.libvirt_conn.lookupByID.side_effect = lambda xid: { 0: MockVM("Domain-0"), 1: MockVM("test-template"), @@ -3862,7 +3866,8 @@ def __init__(self, name): def name(self): return self._name - loop = asyncio.get_event_loop() + loop = asyncio.new_event_loop() + asyncio.set_event_loop(loop) self.app.vmm.libvirt_conn.lookupByID.side_effect = lambda xid: { 0: MockVM("Domain-0"), 1: MockVM("test-template"), diff --git a/qubes/tests/api_internal.py b/qubes/tests/api_internal.py index 5646c2523..b08b6622a 100644 --- a/qubes/tests/api_internal.py +++ b/qubes/tests/api_internal.py @@ -79,7 +79,8 @@ def call_mgmt_func(self, method, arg=b"", payload=b""): self.app, b"dom0", method, b"dom0", arg ) - loop = asyncio.get_event_loop() + loop = asyncio.new_event_loop() + asyncio.set_event_loop(loop) response = loop.run_until_complete( mgmt_obj.execute(untrusted_payload=payload) ) diff --git a/qubes/tests/api_misc.py b/qubes/tests/api_misc.py index cf885abcd..16395be64 100644 --- a/qubes/tests/api_misc.py +++ b/qubes/tests/api_misc.py @@ -63,7 +63,8 @@ def call_mgmt_func(self, method, arg=b"", payload=b""): self.app, b"test-vm", method, b"dom0", arg ) - loop = asyncio.get_event_loop() + loop = asyncio.new_event_loop() + asyncio.set_event_loop(loop) response = loop.run_until_complete( mgmt_obj.execute(untrusted_payload=payload) ) diff --git a/qubes/tests/devices_block.py b/qubes/tests/devices_block.py index dfd2d0d3f..f82d51e35 100644 --- a/qubes/tests/devices_block.py +++ b/qubes/tests/devices_block.py @@ -39,7 +39,8 @@ def async_test(f): def wrapper(*args, **kwargs): coro = asyncio.coroutine(f) future = coro(*args, **kwargs) - loop = asyncio.get_event_loop() + loop = asyncio.new_event_loop() + asyncio.set_event_loop(loop) loop.run_until_complete(future) return wrapper @@ -1124,9 +1125,8 @@ def test_071_failed_confirmation(self, socket): socket.return_value = "allow:nonsense" - loop = asyncio.get_event_loop() self.ext.attach_and_notify = AsyncMock() - loop.run_until_complete( + asyncio.run( qubes.ext.utils.resolve_conflicts_and_attach( self.ext, {"sda": {front: assign, back: assign}} ) @@ -1149,9 +1149,8 @@ def test_072_successful_confirmation(self, socket): socket.return_value = "allow:front-vm" - loop = asyncio.get_event_loop() self.ext.attach_and_notify = AsyncMock() - loop.run_until_complete( + asyncio.run( qubes.ext.utils.resolve_conflicts_and_attach( self.ext, {"sda": {front: assign, back: assign}} ) @@ -1203,10 +1202,9 @@ def test_080_on_startup_multiple_assignments_including_full(self): ) self.ext.attach_and_notify = Mock() - loop = asyncio.get_event_loop() with mock.patch("asyncio.wait"): with mock.patch("asyncio.ensure_future"): - loop.run_until_complete(self.ext.on_domain_start(front, None)) + asyncio.run(self.ext.on_domain_start(front, None)) self.assertEqual( self.ext.attach_and_notify.call_args[0][1].options, {"pid": "did"} ) @@ -1235,10 +1233,9 @@ def test_081_on_startup_multiple_assignments_port_vs_dev(self): ) self.ext.attach_and_notify = Mock() - loop = asyncio.get_event_loop() with mock.patch("asyncio.wait"): with mock.patch("asyncio.ensure_future"): - loop.run_until_complete(self.ext.on_domain_start(front, None)) + asyncio.run(self.ext.on_domain_start(front, None)) self.assertEqual( self.ext.attach_and_notify.call_args[0][1].options, {"pid": "any"} ) @@ -1270,10 +1267,9 @@ def test_082_on_startup_multiple_assignments_dev(self): ) self.ext.attach_and_notify = Mock() - loop = asyncio.get_event_loop() with mock.patch("asyncio.wait"): with mock.patch("asyncio.ensure_future"): - loop.run_until_complete(self.ext.on_domain_start(front, None)) + asyncio.run(self.ext.on_domain_start(front, None)) self.assertEqual( self.ext.attach_and_notify.call_args[0][1].options, {"any": "did"} ) @@ -1299,7 +1295,6 @@ def test_083_on_startup_already_attached(self): back.devices["block"]._exposed.append(exp_dev) self.ext.attach_and_notify = Mock() - loop = asyncio.get_event_loop() with mock.patch("asyncio.ensure_future"): - loop.run_until_complete(self.ext.on_domain_start(front, None)) + asyncio.run(self.ext.on_domain_start(front, None)) self.ext.attach_and_notify.assert_not_called() diff --git a/qubes/tests/events.py b/qubes/tests/events.py index 8d24c68e9..0806bf392 100644 --- a/qubes/tests/events.py +++ b/qubes/tests/events.py @@ -151,7 +151,8 @@ async def on_testevent_3(self, event): def on_testevent_4(self, event): return ("testvalue4",) - loop = asyncio.get_event_loop() + loop = asyncio.new_event_loop() + asyncio.set_event_loop(loop) emitter = TestEmitter() emitter.events_enabled = True diff --git a/qubes/tests/integ/backupcompatibility.py b/qubes/tests/integ/backupcompatibility.py index e45404b9a..efe50fb59 100644 --- a/qubes/tests/integ/backupcompatibility.py +++ b/qubes/tests/integ/backupcompatibility.py @@ -473,7 +473,7 @@ def assertRestored(self, name, **kwargs): with self.assertNotRaises((KeyError, qubes.exc.QubesException)): vm = self.app.domains[name] - asyncio.get_event_loop().run_until_complete(vm.storage.verify()) + asyncio.run(vm.storage.verify()) for prop, value in kwargs.items(): if prop == "klass": self.assertIsInstance(vm, value) diff --git a/qubes/tools/qubes_create.py b/qubes/tools/qubes_create.py index b3853a5b5..39e20b154 100644 --- a/qubes/tools/qubes_create.py +++ b/qubes/tools/qubes_create.py @@ -40,7 +40,7 @@ def main(args=None): """ args = parser.parse_args(args) - asyncio.get_event_loop().run_until_complete( + asyncio.run( qubes.Qubes.create_empty_store( args.app, offline_mode=args.offline_mode ).setup_pools() diff --git a/qubes/tools/qubesd.py b/qubes/tools/qubesd.py index b3cc0da22..4ef4da246 100644 --- a/qubes/tools/qubesd.py +++ b/qubes/tools/qubesd.py @@ -40,7 +40,8 @@ def sighandler(loop, signame, servers): def main(args=None): - loop = asyncio.get_event_loop() + loop = asyncio.new_event_loop() + asyncio.set_event_loop(loop) libvirtaio.virEventRegisterAsyncIOImpl(loop=loop) try: args = parser.parse_args(args) diff --git a/qubes/tools/qubesd_query.py b/qubes/tools/qubesd_query.py index 9a5e3c3e0..cc4d416d1 100644 --- a/qubes/tools/qubesd_query.py +++ b/qubes/tools/qubesd_query.py @@ -112,7 +112,8 @@ async def qubesd_client(socket, payload, *args): # pylint: disable=too-many-return-statements def main(args=None): args = parser.parse_args(args) - loop = asyncio.get_event_loop() + loop = asyncio.new_event_loop() + asyncio.set_event_loop(loop) max_payload_size = 1024 if args.single_line else MAX_PAYLOAD_SIZE if args.max_bytes is not None: diff --git a/qubes/vm/__init__.py b/qubes/vm/__init__.py index d4751e8cb..be5a0d522 100644 --- a/qubes/vm/__init__.py +++ b/qubes/vm/__init__.py @@ -616,7 +616,7 @@ def start_qdb_watch(self, loop=None): self._qdb_connection_watch = qubesdb.QubesDB(self.name) if loop is None: - loop = asyncio.get_event_loop() + loop = asyncio.get_running_loop() loop.add_reader( self._qdb_connection_watch.watch_fd(), self._qdb_watch_reader, loop ) From 44054d0e3c6b96d05ccf3fab7d923c3080608a2a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marek=20Marczykowski-G=C3=B3recki?= Date: Fri, 29 May 2026 04:29:51 +0200 Subject: [PATCH 2/5] Fix getting event loop when initializing Qubes() instance During qubesd startup, the event loop is already created, but it isn't running yet. Use get_event_loop(), not get_running_loop(). QubesOS/qubes-issues#10188 --- qubes/vm/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qubes/vm/__init__.py b/qubes/vm/__init__.py index be5a0d522..d4751e8cb 100644 --- a/qubes/vm/__init__.py +++ b/qubes/vm/__init__.py @@ -616,7 +616,7 @@ def start_qdb_watch(self, loop=None): self._qdb_connection_watch = qubesdb.QubesDB(self.name) if loop is None: - loop = asyncio.get_running_loop() + loop = asyncio.get_event_loop() loop.add_reader( self._qdb_connection_watch.watch_fd(), self._qdb_watch_reader, loop ) From ab75e458a00610da21e1708e98ad020632f7093b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marek=20Marczykowski-G=C3=B3recki?= Date: Sat, 30 May 2026 13:37:27 +0200 Subject: [PATCH 3/5] tests: cancel all remaining tasks between tests execution If old loop still has some tasks, bad things happen (mostly timeouts waiting for no longer existing objects). While theoretically all tasks should be completed by the time test ends, ensure that by cancelling them all (and logging a warning if there were any). --- qubes/tests/__init__.py | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/qubes/tests/__init__.py b/qubes/tests/__init__.py index 6bfb4c7af..ba74997af 100644 --- a/qubes/tests/__init__.py +++ b/qubes/tests/__init__.py @@ -594,6 +594,25 @@ def cleanup_loop(self): self.loop.stop() self.loop.run_forever() + # and finally, cancel remaining tasks + to_cancel = asyncio.all_tasks(self.loop) + if to_cancel: + for task in to_cancel: + self.log.warning("Leftover task: %r", task) + task.cancel() + + self.loop.run_until_complete(asyncio.gather(*to_cancel, return_exceptions=True)) + + for task in to_cancel: + if task.cancelled(): + continue + if task.exception() is not None: + self.log.warning("Unhandled exception during test %r shutdown: %r", + task, + task.exception(), + ) + + # Check there are no Tasks left. assert not self.loop._ready assert not self.loop._scheduled From cfb6fa1a66e1a3bae5754f8d75c8bd0f5270ea5d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marek=20Marczykowski-G=C3=B3recki?= Date: Sat, 30 May 2026 15:29:27 +0200 Subject: [PATCH 4/5] tests: fix initializing event loop Do not create new event loop for every test, that makes various FD readers and events not working anymore. While theoretically it should be possible to find and re-register them all, it isn't worth it. And also, register libvirt event loop only after creating asyncio one. --- qubes/tests/__init__.py | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/qubes/tests/__init__.py b/qubes/tests/__init__.py index ba74997af..ad6bfd614 100644 --- a/qubes/tests/__init__.py +++ b/qubes/tests/__init__.py @@ -494,11 +494,6 @@ def __init__(self, methodName="runTest"): self._success = True - global libvirt_event_impl - - if in_dom0 and not libvirt_event_impl: - libvirt_event_impl = libvirtaio.virEventRegisterAsyncIOImpl() - def set_result(self, success): self._success = success @@ -513,8 +508,17 @@ def setUp(self): super().setUp() self.addCleanup(self.cleanup_gc) - self.loop = asyncio.new_event_loop() + try: + self.loop = asyncio.get_event_loop() + except RuntimeError: + self.loop = asyncio.new_event_loop() asyncio.set_event_loop(self.loop) + + global libvirt_event_impl + + if in_dom0 and not libvirt_event_impl: + libvirt_event_impl = libvirtaio.virEventRegisterAsyncIOImpl() + self.addCleanup(self.cleanup_loop) self.kernel_validator_original = qubes.app.validate_kernel From b5038e92ad64bf9ca4eaea99078a11b1e82ceb66 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marek=20Marczykowski-G=C3=B3recki?= Date: Sun, 31 May 2026 03:17:23 +0200 Subject: [PATCH 5/5] tests: do not use asyncio.run() or new_event_loop() inside tests asyncio.run() unsets event loop at the end, which breaks any further use of asyncio. But the QubesTestCase.setUp() creates event loop, so using get_event_loop() is okay there. Similarly new_event_loop() is harmful. This reverts significant part of 7e4a837e "Initialize asyncio event loop before using it". Fixes: 7e4a837e "Initialize asyncio event loop before using it" --- qubes/tests/api_admin.py | 15 +++++---------- qubes/tests/api_internal.py | 3 +-- qubes/tests/api_misc.py | 3 +-- qubes/tests/devices_block.py | 21 +++++++++++++-------- qubes/tests/events.py | 3 +-- qubes/tests/integ/backupcompatibility.py | 2 +- 6 files changed, 22 insertions(+), 25 deletions(-) diff --git a/qubes/tests/api_admin.py b/qubes/tests/api_admin.py index a38d99154..b31dc4abe 100644 --- a/qubes/tests/api_admin.py +++ b/qubes/tests/api_admin.py @@ -145,8 +145,7 @@ def call_mgmt_func(self, method, dest, arg=b"", payload=b""): self.app, b"dom0", method, dest, arg ) - loop = asyncio.new_event_loop() - asyncio.set_event_loop(loop) + loop = asyncio.get_event_loop() response = loop.run_until_complete( mgmt_obj.execute(untrusted_payload=payload) ) @@ -159,8 +158,7 @@ def call_internal_mgmt_func(self, method, dest, arg=b"", payload=b""): mgmt_obj = qubes.api.internal.QubesInternalAPI( self.app, b"dom0", method, dest, arg ) - loop = asyncio.new_event_loop() - asyncio.set_event_loop(loop) + loop = asyncio.get_event_loop() response = loop.run_until_complete( mgmt_obj.execute(untrusted_payload=payload) ) @@ -232,8 +230,7 @@ def test_002_vm_list_filter(self): mgmt_obj = qubes.api.admin.QubesAdminAPI( self.app, b"test-vm1", b"admin.vm.List", b"dom0", b"" ) - loop = asyncio.new_event_loop() - asyncio.set_event_loop(loop) + loop = asyncio.get_event_loop() value = loop.run_until_complete( mgmt_obj.execute(untrusted_payload=b"") ) @@ -3765,8 +3762,7 @@ def __init__(self, name): def name(self): return self._name - loop = asyncio.new_event_loop() - asyncio.set_event_loop(loop) + loop = asyncio.get_event_loop() self.app.vmm.libvirt_conn.lookupByID.side_effect = lambda xid: { 0: MockVM("Domain-0"), 1: MockVM("test-template"), @@ -3866,8 +3862,7 @@ def __init__(self, name): def name(self): return self._name - loop = asyncio.new_event_loop() - asyncio.set_event_loop(loop) + loop = asyncio.get_event_loop() self.app.vmm.libvirt_conn.lookupByID.side_effect = lambda xid: { 0: MockVM("Domain-0"), 1: MockVM("test-template"), diff --git a/qubes/tests/api_internal.py b/qubes/tests/api_internal.py index b08b6622a..5646c2523 100644 --- a/qubes/tests/api_internal.py +++ b/qubes/tests/api_internal.py @@ -79,8 +79,7 @@ def call_mgmt_func(self, method, arg=b"", payload=b""): self.app, b"dom0", method, b"dom0", arg ) - loop = asyncio.new_event_loop() - asyncio.set_event_loop(loop) + loop = asyncio.get_event_loop() response = loop.run_until_complete( mgmt_obj.execute(untrusted_payload=payload) ) diff --git a/qubes/tests/api_misc.py b/qubes/tests/api_misc.py index 16395be64..cf885abcd 100644 --- a/qubes/tests/api_misc.py +++ b/qubes/tests/api_misc.py @@ -63,8 +63,7 @@ def call_mgmt_func(self, method, arg=b"", payload=b""): self.app, b"test-vm", method, b"dom0", arg ) - loop = asyncio.new_event_loop() - asyncio.set_event_loop(loop) + loop = asyncio.get_event_loop() response = loop.run_until_complete( mgmt_obj.execute(untrusted_payload=payload) ) diff --git a/qubes/tests/devices_block.py b/qubes/tests/devices_block.py index f82d51e35..dfd2d0d3f 100644 --- a/qubes/tests/devices_block.py +++ b/qubes/tests/devices_block.py @@ -39,8 +39,7 @@ def async_test(f): def wrapper(*args, **kwargs): coro = asyncio.coroutine(f) future = coro(*args, **kwargs) - loop = asyncio.new_event_loop() - asyncio.set_event_loop(loop) + loop = asyncio.get_event_loop() loop.run_until_complete(future) return wrapper @@ -1125,8 +1124,9 @@ def test_071_failed_confirmation(self, socket): socket.return_value = "allow:nonsense" + loop = asyncio.get_event_loop() self.ext.attach_and_notify = AsyncMock() - asyncio.run( + loop.run_until_complete( qubes.ext.utils.resolve_conflicts_and_attach( self.ext, {"sda": {front: assign, back: assign}} ) @@ -1149,8 +1149,9 @@ def test_072_successful_confirmation(self, socket): socket.return_value = "allow:front-vm" + loop = asyncio.get_event_loop() self.ext.attach_and_notify = AsyncMock() - asyncio.run( + loop.run_until_complete( qubes.ext.utils.resolve_conflicts_and_attach( self.ext, {"sda": {front: assign, back: assign}} ) @@ -1202,9 +1203,10 @@ def test_080_on_startup_multiple_assignments_including_full(self): ) self.ext.attach_and_notify = Mock() + loop = asyncio.get_event_loop() with mock.patch("asyncio.wait"): with mock.patch("asyncio.ensure_future"): - asyncio.run(self.ext.on_domain_start(front, None)) + loop.run_until_complete(self.ext.on_domain_start(front, None)) self.assertEqual( self.ext.attach_and_notify.call_args[0][1].options, {"pid": "did"} ) @@ -1233,9 +1235,10 @@ def test_081_on_startup_multiple_assignments_port_vs_dev(self): ) self.ext.attach_and_notify = Mock() + loop = asyncio.get_event_loop() with mock.patch("asyncio.wait"): with mock.patch("asyncio.ensure_future"): - asyncio.run(self.ext.on_domain_start(front, None)) + loop.run_until_complete(self.ext.on_domain_start(front, None)) self.assertEqual( self.ext.attach_and_notify.call_args[0][1].options, {"pid": "any"} ) @@ -1267,9 +1270,10 @@ def test_082_on_startup_multiple_assignments_dev(self): ) self.ext.attach_and_notify = Mock() + loop = asyncio.get_event_loop() with mock.patch("asyncio.wait"): with mock.patch("asyncio.ensure_future"): - asyncio.run(self.ext.on_domain_start(front, None)) + loop.run_until_complete(self.ext.on_domain_start(front, None)) self.assertEqual( self.ext.attach_and_notify.call_args[0][1].options, {"any": "did"} ) @@ -1295,6 +1299,7 @@ def test_083_on_startup_already_attached(self): back.devices["block"]._exposed.append(exp_dev) self.ext.attach_and_notify = Mock() + loop = asyncio.get_event_loop() with mock.patch("asyncio.ensure_future"): - asyncio.run(self.ext.on_domain_start(front, None)) + loop.run_until_complete(self.ext.on_domain_start(front, None)) self.ext.attach_and_notify.assert_not_called() diff --git a/qubes/tests/events.py b/qubes/tests/events.py index 0806bf392..8d24c68e9 100644 --- a/qubes/tests/events.py +++ b/qubes/tests/events.py @@ -151,8 +151,7 @@ async def on_testevent_3(self, event): def on_testevent_4(self, event): return ("testvalue4",) - loop = asyncio.new_event_loop() - asyncio.set_event_loop(loop) + loop = asyncio.get_event_loop() emitter = TestEmitter() emitter.events_enabled = True diff --git a/qubes/tests/integ/backupcompatibility.py b/qubes/tests/integ/backupcompatibility.py index efe50fb59..e45404b9a 100644 --- a/qubes/tests/integ/backupcompatibility.py +++ b/qubes/tests/integ/backupcompatibility.py @@ -473,7 +473,7 @@ def assertRestored(self, name, **kwargs): with self.assertNotRaises((KeyError, qubes.exc.QubesException)): vm = self.app.domains[name] - asyncio.run(vm.storage.verify()) + asyncio.get_event_loop().run_until_complete(vm.storage.verify()) for prop, value in kwargs.items(): if prop == "klass": self.assertIsInstance(vm, value)