On Fri, Jul 30, 2021 at 4:19 PM G S Niteesh Babu <niteesh...@gmail.com> wrote:
> Added a draft of AQMP TUI. > > Implements the follwing basic features: > 1) Command transmission/reception. > 2) Shows events asynchronously. > 3) Shows server status in the bottom status bar. > > Also added necessary pylint, mypy configurations > > Signed-off-by: G S Niteesh Babu <niteesh...@gmail.com> > --- > python/qemu/aqmp/aqmp_tui.py | 333 +++++++++++++++++++++++++++++++++++ > python/setup.cfg | 16 +- > 2 files changed, 348 insertions(+), 1 deletion(-) > create mode 100644 python/qemu/aqmp/aqmp_tui.py > > diff --git a/python/qemu/aqmp/aqmp_tui.py b/python/qemu/aqmp/aqmp_tui.py > new file mode 100644 > index 0000000000..ec9eba0aa7 > --- /dev/null > +++ b/python/qemu/aqmp/aqmp_tui.py > @@ -0,0 +1,333 @@ > +# Copyright (c) 2021 > +# > +# Authors: > +# Niteesh Babu G S <niteesh...@gmail.com> > +# > +# This work is licensed under the terms of the GNU GPL, version 2 or > +# later. See the COPYING file in the top-level directory. > + > +import argparse > +import asyncio > +import logging > +from logging import Handler > +import signal > + > +import urwid > +import urwid_readline > + > +from ..qmp import QEMUMonitorProtocol, QMPBadPortError > +from .message import DeserializationError, Message, UnexpectedTypeError > +from .protocol import ConnectError > +from .qmp_client import ExecInterruptedError, QMPClient > +from .util import create_task, pretty_traceback > + > + > +UPDATE_MSG = 'UPDATE_MSG' > + > +# Using root logger to enable all loggers under qemu and asyncio > +LOGGER = logging.getLogger() > + > + > +def format_json(msg): > + """ > + Formats given multiline JSON message into a single line message. > + Converting into single line is more asthetically pleasing when looking > + along with error messages compared to multiline JSON. > + """ > + # FIXME: Use better formatting mechanism. Might break at more complex > JSON > + # data. > + msg = msg.replace('\n', '') > + words = msg.split(' ') > + words = [word for word in words if word != ''] > + return ' '.join(words) > + > + > +class App(QMPClient): > + def __init__(self, address): > + urwid.register_signal(type(self), UPDATE_MSG) > + self.window = Window(self) > + self.address = address > + self.aloop = None > + super().__init__() > + > + def add_to_history(self, msg): > + urwid.emit_signal(self, UPDATE_MSG, msg) > + > + def _cb_outbound(self, msg): > + # FIXME: I think the ideal way to omit these messages during > in-TUI > + # logging will be to add a filter to the logger. We can use regex > to > + # filter out messages starting with 'Request:' or 'Response:' but > I > + # think a better approach will be encapsulate the message in an > object > + # and filter based on the object. Encapsulation of the message > will > + # also be necessary when we want different formatting of messages > + # inside TUI. > + handler = LOGGER.handlers[0] > + if not isinstance(handler, TUILogHandler): > + LOGGER.debug('Request: %s', str(msg)) > + self.add_to_history('<-- ' + str(msg)) > + return msg > + > + def _cb_inbound(self, msg): > + handler = LOGGER.handlers[0] > + if not isinstance(handler, TUILogHandler): > + LOGGER.debug('Response: %s', str(msg)) > + self.add_to_history('--> ' + str(msg)) > + return msg > + > + async def wait_for_events(self): > + async for event in self.events: > + self.handle_event(event) > + > + async def _send_to_server(self, raw_msg): > + # FIXME: Format the raw_msg in history view to one line. It is not > + # pleasing to see multiple lines JSON object with an error > statement. > + try: > + msg = Message(bytes(raw_msg, encoding='utf-8')) > + # Format multiline json into a single line JSON, since it is > more > + # pleasing to look along with err message in TUI. > + raw_msg = self.format_json(raw_msg) > + await self._raw(msg, assign_id='id' not in msg) > + except (ValueError, TypeError) as err: > + LOGGER.info('Invalid message: %s', str(err)) > + self.add_to_history(f'{raw_msg}: {err}') > + except (DeserializationError, UnexpectedTypeError) as err: > + LOGGER.info('Invalid message: %s', err.error_message) > + self.add_to_history(f'{raw_msg}: {err.error_message}') > + except ExecInterruptedError: > + LOGGER.info('Error server disconnected before reply') > + urwid.emit_signal(self, UPDATE_MSG, > + '{"error": "Server disconnected before > reply"}') > + self._set_status("Server disconnected") > + except Exception as err: > + LOGGER.error('Exception from _send_to_server: %s', str(err)) > + raise err > + > + def cb_send_to_server(self, msg): > + create_task(self._send_to_server(msg)) > + > + def unhandled_input(self, key): > + if key == 'esc': > + self.kill_app() > + > + def kill_app(self): > + # TODO: Work on the disconnect logic > + create_task(self._kill_app()) > + > + async def _kill_app(self): > + # It is ok to call disconnect even in disconnect state > + try: > + await self.disconnect() > + LOGGER.debug('Disconnect finished. Exiting app') > + except Exception as err: > + LOGGER.info('_kill_app: %s', str(err)) > + # Let the app crash after providing a proper stack trace > + raise err > + raise urwid.ExitMainLoop() > + > + def handle_event(self, event): > + # FIXME: Consider all states present in qapi/run-state.json > + if event['event'] == 'SHUTDOWN': > + self._set_status('Server shutdown') > + > + def _set_status(self, msg: str) -> None: > + self.window.footer.set_text(msg) > + > + def _get_formatted_address(self) -> str: > + addr = f'{self.address}' > + if isinstance(self.address, tuple): > + host, port = self.address > + addr = f'{host}:{port}' > + return addr > + > + async def connect_server(self): > + try: > + await self.connect(self.address) > + addr = self._get_formatted_address() > + self._set_status(f'Connected to {addr}') > + except ConnectError as err: > + LOGGER.info('connect_server: ConnectError %s', str(err)) > + self._set_status('Server shutdown') > + > + def run(self, debug=False): > + self.aloop = asyncio.get_event_loop() > + self.aloop.set_debug(debug) > + > + # Gracefully handle SIGTERM and SIGINT signals > + cancel_signals = [signal.SIGTERM, signal.SIGINT] > + for sig in cancel_signals: > + self.aloop.add_signal_handler(sig, self.kill_app) > + > + event_loop = urwid.AsyncioEventLoop(loop=self.aloop) > + main_loop = urwid.MainLoop(urwid.AttrMap(self.window, > 'background'), > + unhandled_input=self.unhandled_input, > + handle_mouse=True, > + event_loop=event_loop) > + > + create_task(self.wait_for_events(), self.aloop) > + create_task(self.connect_server(), self.aloop) > + try: > + main_loop.run() > + except Exception as err: > + LOGGER.error('%s\n%s\n', str(err), pretty_traceback()) > + raise err > + > + > +class StatusBar(urwid.Text): > + """ > + A simple Text widget that currently only shows connection status. > + """ > + def __init__(self, text=''): > + super().__init__(text, align='right') > + > + > +class Editor(urwid_readline.ReadlineEdit): > + """ > + Support urwid_readline features along with > + history support which lacks in urwid_readline > + """ > + def __init__(self, master): > + super().__init__(caption='> ', multiline=True) > + self.master = master > + self.history = [] > + self.last_index = -1 > + self.show_history = False > + > + def keypress(self, size, key): > + # TODO: Add some logic for down key and clean up logic if > possible. > + # Returning None means the key has been handled by this widget > + # which otherwise is propogated to the parent widget to be > + # handled > + msg = self.get_edit_text() > + if key == 'up' and not msg: > + # Show the history when 'up arrow' is pressed with no input > text. > + # NOTE: The show_history logic is necessary because in > 'multiline' > + # mode (which we use) 'up arrow' is used to move between > lines. > + self.show_history = True > + last_msg = self.history[self.last_index] if self.history else > '' > + self.set_edit_text(last_msg) > + self.edit_pos = len(last_msg) > + self.last_index += 1 > + elif key == 'up' and self.show_history: > + if self.last_index < len(self.history): > + self.set_edit_text(self.history[self.last_index]) > + self.edit_pos = len(self.history[self.last_index]) > + self.last_index += 1 > + elif key == 'meta enter': > + # When using multiline, enter inserts a new line into the > editor > + # send the input to the server on alt + enter > + self.master.cb_send_to_server(msg) > cb_send_to_server calls create_task(App._send_to_server(msg)) at which point in the coroutine you finally do msg = Message(bytes(raw_msg, encoding='utf-8')). However, you can do your message conversion *first*, here in the Editor. That way, you can avoid erasing the editor bar when the message is garbled and the user has a chance to fix the corrupted message *first* before we dispatch to the callback-async-machine. That should reduce quite a lot of the error cases in _send_to_server and helps separate out the two kinds of errors we expect to see here: 1. The user typed something that's garbage, and we didn't actually even send it (because we couldn't), and 2. We sent (or tried to send) the message; but a failure occurred. > + self.history.insert(0, msg) > + self.set_edit_text('') > + self.last_index = 0 > + self.show_history = False > + else: > + self.show_history = False > + self.last_index = 0 > + return super().keypress(size, key) > + return None > + > + > +class EditorWidget(urwid.Filler): > + """ > + Wraps CustomEdit > + """ > + def __init__(self, master): > + super().__init__(Editor(master), valign='top') > + > + > +class HistoryBox(urwid.ListBox): > + """ > + Shows all the QMP message transmitted/received > + """ > + def __init__(self, master): > + self.master = master > + self.history = urwid.SimpleFocusListWalker([]) > + super().__init__(self.history) > + > + def add_to_history(self, history): > + self.history.append(urwid.Text(history)) > + if self.history: > + self.history.set_focus(len(self.history) - 1) > + > + > +class HistoryWindow(urwid.Frame): > + """ > + Composes the HistoryBox and EditorWidget > + """ > + def __init__(self, master): > + self.master = master > + self.editor_widget = EditorWidget(master) > + self.editor = urwid.LineBox(self.editor_widget) > + self.history = HistoryBox(master) > + self.body = urwid.Pile([('weight', 80, self.history), > + ('weight', 20, self.editor)]) > + super().__init__(self.body) > + urwid.connect_signal(self.master, UPDATE_MSG, > self.cb_add_to_history) > + > + def cb_add_to_history(self, msg): > + self.history.add_to_history(msg) > + > + > +class Window(urwid.Frame): > + """ > + This is going to be the main window that is going to compose other > + windows. In this stage it is unnecesssary but will be necessary in > + future when we will have multiple windows and want to the switch > between > + them and display overlays > + """ > + def __init__(self, master): > + self.master = master > + footer = StatusBar() > + body = HistoryWindow(master) > + super().__init__(body, footer=footer) > + > + > +class TUILogHandler(Handler): > + def __init__(self, tui): > + super().__init__() > + self.tui = tui > + > + def emit(self, record): > + level = record.levelname > + msg = record.getMessage() > + msg = f'[{level}]: {msg}' > + self.tui.add_to_history(msg) > + > + > +def main(): > + parser = argparse.ArgumentParser(description='AQMP TUI') > + parser.add_argument('qmp_server', help='Address of the QMP server' > + '< UNIX socket path | TCP addr:port >') > + parser.add_argument('--log-file', help='The Log file name') > + parser.add_argument('--log-level', default='WARNING', > + help='Log level > <CRITICAL|ERROR|WARNING|INFO|DEBUG|>') > + parser.add_argument('--asyncio-debug', action='store_true', > + help='Enable debug mode for asyncio loop' > + 'Generates lot of output, makes TUI unusable when' > + 'logs are logged in the TUI itself.' > + 'Use only when logging to a file') > + args = parser.parse_args() > + > + try: > + address = QEMUMonitorProtocol.parse_address(args.qmp_server) > + except QMPBadPortError as err: > + parser.error(err) > + > + app = App(address) > + > + if args.log_file: > + LOGGER.addHandler(logging.FileHandler(args.log_file)) > + else: > + LOGGER.addHandler(TUILogHandler(app)) > + > + log_level = logging.getLevelName(args.log_level) > + # getLevelName returns 'Level {log_level}' when a invalid level is > passed. > + if log_level == f'Level {args.log_level}': > + parser.error('Invalid log level') > + LOGGER.setLevel(log_level) > + > + app.run(args.asyncio_debug) > + > + > +if __name__ == '__main__': > + main() # type: ignore > diff --git a/python/setup.cfg b/python/setup.cfg > index d106a0ed7a..50f9894468 100644 > --- a/python/setup.cfg > +++ b/python/setup.cfg > @@ -81,8 +81,22 @@ namespace_packages = True > # fusepy has no type stubs: > allow_subclassing_any = True > > +[mypy-qemu.aqmp.aqmp_tui] > +disallow_untyped_defs = False > +disallow_incomplete_defs = False > +check_untyped_defs = False > +# urwid and urwid_readline have no type stubs: > +allow_subclassing_any = True > + > +# The following missing import directives are because these libraries do > not > +# provide type stubs. Allow them on an as-needed basis for mypy. > [mypy-fuse] > -# fusepy has no type stubs: > +ignore_missing_imports = True > + > +[mypy-urwid] > +ignore_missing_imports = True > + > +[mypy-urwid_readline] > ignore_missing_imports = True > > [pylint.messages control] > -- > 2.17.1 > >