fridtjof/qemu-cr16
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

python: backport 'avoid creating additional event loops per thread'

Browse source 
This commit is two backports squashed into one to avoid regressions.

python: *really* remove get_event_loop

A prior commit, aa1ff990, switched away from using get_event_loop *by
default*, but this is not good enough to avoid deprecation warnings as
`asyncio.get_event_loop_policy().get_event_loop()` is *also*
deprecated. Replace this mechanism with explicit calls to
asyncio.get_new_loop() and revise the cleanup mechanisms in __del__ to
match.

python: avoid creating additional event loops per thread

"Too hasty by far!", commit 21ce2ee4 attempted to avoid deprecated
behavior altogether by calling new_event_loop() directly if there was no
loop currently running, but this has the unfortunate side effect of
potentially creating multiple event loops per thread if tests
instantiate multiple QMP connections in a single thread. This behavior
is apparently not well-defined and causes problems in some, but not all,
combinations of Python interpreter version and platform environment.

Partially revert to Daniel Berrange's original patch, which calls
get_event_loop and simply suppresses the deprecation warning in
Python<=3.13. This time, however, additionally register new loops
created with new_event_loop() so that future calls to get_event_loop()
will return the loop already created.

Reported-by: Richard W.M. Jones <rjones@redhat.com>
Reported-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: John Snow <jsnow@redhat.com>
cherry picked from commit python-qemu-qmp@21ce2ee4f2df87efe84a27b9c5112487f4670622
cherry picked from commit python-qemu-qmp@c08fb82b38212956ccffc03fc6d015c3979f42fe
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
This commit is contained in:
John Snow 2025-09-03 01:06:30 -04:00
parent 5d99044d09
commit 85f223e5b0
3 changed files with 57 additions and 26 deletions
Download patch file Download diff file Expand all files Collapse all files

46
python/qemu/qmp/legacy.py
View file

@ -38,6 +38,7 @@ from typing import (
from .error import QMPError
from .protocol import Runstate, SocketAddrT
from .qmp_client import QMPClient
from .util import get_or_create_event_loop
#: QMPMessage is an entire QMP message of any kind.
@ -86,17 +87,13 @@ class QEMUMonitorProtocol:
"server argument should be False when passing a socket")
self._qmp = QMPClient(nickname)
try:
self._aloop = asyncio.get_running_loop()
except RuntimeError:
# No running loop; since this is a sync shim likely to be
# used in fully sync programs, create one if neccessary.
self._aloop = asyncio.get_event_loop_policy().get_event_loop()
self._address = address
self._timeout: Optional[float] = None
# This is a sync shim intended for use in fully synchronous
# programs. Create and set an event loop if necessary.
self._aloop = get_or_create_event_loop()
if server:
assert not isinstance(self._address, socket.socket)
self._sync(self._qmp.start_server(self._address))
@ -313,17 +310,30 @@ class QEMUMonitorProtocol:
self._qmp.send_fd_scm(fd)
def __del__(self) -> None:
if self._qmp.runstate == Runstate.IDLE:
return
if self._qmp.runstate != Runstate.IDLE:
self._qmp.logger.warning(
"QEMUMonitorProtocol object garbage collected without a prior "
"call to close()"
)
if not self._aloop.is_running():
self.close()
else:
# Garbage collection ran while the event loop was running.
# Nothing we can do about it now, but if we don't raise our
# own error, the user will be treated to a lot of traceback
# they might not understand.
if self._qmp.runstate != Runstate.IDLE:
# If the user neglected to close the QMP session and we
# are not currently running in an asyncio context, we
# have the opportunity to close the QMP session. If we
# do not do this, the error messages presented over
# dangling async resources may not make any sense to the
# user.
self.close()
if self._qmp.runstate != Runstate.IDLE:
# If QMP is still not quiesced, it means that the garbage
# collector ran from a context within the event loop and we
# are simply too late to take any corrective action. Raise
# our own error to give meaningful feedback to the user in
# order to prevent pages of asyncio stacktrace jargon.
raise QMPError(
"QEMUMonitorProtocol.close()"
" was not called before object was garbage collected"
"QEMUMonitorProtocol.close() was not called before object was "
"garbage collected, and could not be closed due to GC running "
"in the event loop"
)

10
python/qemu/qmp/qmp_tui.py
View file

@ -51,7 +51,7 @@ from .legacy import QEMUMonitorProtocol, QMPBadPortError
from .message import DeserializationError, Message, UnexpectedTypeError
from .protocol import ConnectError, Runstate
from .qmp_client import ExecInterruptedError, QMPClient
from .util import pretty_traceback
from .util import get_or_create_event_loop, pretty_traceback
# The name of the signal that is used to update the history list
@ -387,13 +387,7 @@ class App(QMPClient):
"""
screen = urwid.raw_display.Screen()
screen.set_terminal_properties(256)
try:
self.aloop = asyncio.get_running_loop()
except RuntimeError:
# No running asyncio event loop. Create one if necessary.
self.aloop = asyncio.get_event_loop_policy().get_event_loop()
self.aloop = get_or_create_event_loop()
self.aloop.set_debug(debug)
# Gracefully handle SIGTERM and SIGINT signals

27
python/qemu/qmp/util.py
View file

@ -10,6 +10,7 @@ import asyncio
import sys
import traceback
from typing import TypeVar, cast
import warnings
T = TypeVar('T')
@ -20,6 +21,32 @@ T = TypeVar('T')
# --------------------------
def get_or_create_event_loop() -> asyncio.AbstractEventLoop:
"""
Return this thread's current event loop, or create a new one.
This function behaves similarly to asyncio.get_event_loop() in
Python<=3.13, where if there is no event loop currently associated
with the current context, it will create and register one. It should
generally not be used in any asyncio-native applications.
"""
try:
with warnings.catch_warnings():
# Python <= 3.13 will trigger deprecation warnings if no
# event loop is set, but will create and set a new loop.
warnings.simplefilter("ignore")
loop = asyncio.get_event_loop()
except RuntimeError:
# Python 3.14+: No event loop set for this thread,
# create and set one.
loop = asyncio.new_event_loop()
# Set this loop as the current thread's loop, to be returned
# by calls to get_event_loop() in the future.
asyncio.set_event_loop(loop)
return loop
async def flush(writer: asyncio.StreamWriter) -> None:
"""
Utility function to ensure a StreamWriter is *fully* drained.