Debian Codegraph @

mandos-monitor

raw
1 #!/usr/bin/python3 -bbI
2 # -*- mode: python; coding: utf-8 -*-
3 #
4 # Mandos Monitor - Control and monitor the Mandos server
5 #
6 # Copyright © 2009-2024 Teddy Hogeborn
7 # Copyright © 2009-2024 Björn Påhlsson
8 #
9 # This file is part of Mandos.
10 #
11 # Mandos is free software: you can redistribute it and/or modify it
12 # under the terms of the GNU General Public License as published by
13 # the Free Software Foundation, either version 3 of the License, or
14 # (at your option) any later version.
15 #
16 # Mandos is distributed in the hope that it will be useful, but
17 # WITHOUT ANY WARRANTY; without even the implied warranty of
18 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 # GNU General Public License for more details.
20 #
21 # You should have received a copy of the GNU General Public License
22 # along with Mandos. If not, see <http://www.gnu.org/licenses/>.
23 #
24 # Contact the authors at <[email protected]>.
25 #
26 from __future__ import (division, absolute_import, print_function,
27 unicode_literals)
28
29 try:
30 from future_builtins import *
31 except ImportError:
32 pass
33
34 import sys
35 import logging
36 import os
37 import warnings
38 import datetime
39 import locale
40
41 import urwid.curses_display
42 import urwid
43
44 from dbus.mainloop.glib import DBusGMainLoop
45 from gi.repository import GLib
46
47 import dbus
48
49 if sys.version_info.major == 2:
50 __metaclass__ = type
51 str = unicode
52 input = raw_input
53
54 # Show warnings by default
55 if not sys.warnoptions:
56 warnings.simplefilter("default")
57
58 log = logging.getLogger(os.path.basename(sys.argv[0]))
59 logging.basicConfig(level="NOTSET", # Show all messages
60 format="%(message)s") # Show basic log messages
61
62 logging.captureWarnings(True) # Show warnings via the logging system
63
64 locale.setlocale(locale.LC_ALL, "")
65
66 logging.getLogger("dbus.proxies").setLevel(logging.CRITICAL)
67 logging.getLogger("urwid").setLevel(logging.INFO)
68
69 # Some useful constants
70 domain = "se.recompile"
71 server_interface = domain + ".Mandos"
72 client_interface = domain + ".Mandos.Client"
73 version = "1.8.19"
74
75 try:
76 dbus.OBJECT_MANAGER_IFACE
77 except AttributeError:
78 dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
79
80
81 def isoformat_to_datetime(iso):
82 "Parse an ISO 8601 date string to a datetime.datetime()"
83 if not iso:
84 return None
85 d, t = iso.split("T", 1)
86 year, month, day = d.split("-", 2)
87 hour, minute, second = t.split(":", 2)
88 second, fraction = divmod(float(second), 1)
89 return datetime.datetime(int(year),
90 int(month),
91 int(day),
92 int(hour),
93 int(minute),
94 int(second), # Whole seconds
95 int(fraction*1000000)) # Microseconds
96
97
98 class MandosClientPropertyCache:
99 """This wraps a Mandos Client D-Bus proxy object, caches the
100 properties and calls a hook function when any of them are
101 changed.
102 """
103 def __init__(self, proxy_object=None, properties=None, **kwargs):
104 self.proxy = proxy_object # Mandos Client proxy object
105 self.properties = dict() if properties is None else properties
106 self.property_changed_match = (
107 self.proxy.connect_to_signal("PropertiesChanged",
108 self.properties_changed,
109 dbus.PROPERTIES_IFACE,
110 byte_arrays=True))
111
112 if properties is None:
113 self.properties.update(self.proxy.GetAll(
114 client_interface,
115 dbus_interface=dbus.PROPERTIES_IFACE))
116
117 super(MandosClientPropertyCache, self).__init__(**kwargs)
118
119 def properties_changed(self, interface, properties, invalidated):
120 """This is called whenever we get a PropertiesChanged signal
121 It updates the changed properties in the "properties" dict.
122 """
123 # Update properties dict with new value
124 if interface == client_interface:
125 self.properties.update(properties)
126
127 def delete(self):
128 self.property_changed_match.remove()
129
130
131 class MandosClientWidget(MandosClientPropertyCache, urwid.Widget):
132 """A Mandos Client which is visible on the screen.
133 """
134
135 _sizing = frozenset(["flow"])
136
137 def __init__(self, server_proxy_object=None, update_hook=None,
138 delete_hook=None, **kwargs):
139 # Called on update
140 self.update_hook = update_hook
141 # Called on delete
142 self.delete_hook = delete_hook
143 # Mandos Server proxy object
144 self.server_proxy_object = server_proxy_object
145
146 self._update_timer_callback_tag = None
147
148 # The widget shown normally
149 self._text_widget = urwid.Text("")
150 # The widget shown when we have focus
151 self._focus_text_widget = urwid.Text("")
152 super(MandosClientWidget, self).__init__(**kwargs)
153 self.update()
154 self.opened = False
155
156 self.match_objects = (
157 self.proxy.connect_to_signal("CheckerCompleted",
158 self.checker_completed,
159 client_interface,
160 byte_arrays=True),
161 self.proxy.connect_to_signal("CheckerStarted",
162 self.checker_started,
163 client_interface,
164 byte_arrays=True),
165 self.proxy.connect_to_signal("GotSecret",
166 self.got_secret,
167 client_interface,
168 byte_arrays=True),
169 self.proxy.connect_to_signal("NeedApproval",
170 self.need_approval,
171 client_interface,
172 byte_arrays=True),
173 self.proxy.connect_to_signal("Rejected",
174 self.rejected,
175 client_interface,
176 byte_arrays=True))
177 log.debug("Created client %s", self.properties["Name"])
178
179 def using_timer(self, flag):
180 """Call this method with True or False when timer should be
181 activated or deactivated.
182 """
183 if flag and self._update_timer_callback_tag is None:
184 # Will update the shown timer value every second
185 self._update_timer_callback_tag = (
186 GLib.timeout_add(1000,
187 glib_safely(self.update_timer)))
188 elif not (flag or self._update_timer_callback_tag is None):
189 GLib.source_remove(self._update_timer_callback_tag)
190 self._update_timer_callback_tag = None
191
192 def checker_completed(self, exitstatus, condition, command):
193 if exitstatus == 0:
194 log.debug('Checker for client %s (command "%s")'
195 " succeeded", self.properties["Name"], command)
196 self.update()
197 return
198 # Checker failed
199 if os.WIFEXITED(condition):
200 log.info('Checker for client %s (command "%s") failed'
201 " with exit code %d", self.properties["Name"],
202 command, os.WEXITSTATUS(condition))
203 elif os.WIFSIGNALED(condition):
204 log.info('Checker for client %s (command "%s") was'
205 " killed by signal %d", self.properties["Name"],
206 command, os.WTERMSIG(condition))
207 self.update()
208
209 def checker_started(self, command):
210 """Server signals that a checker started."""
211 log.debug('Client %s started checker "%s"',
212 self.properties["Name"], command)
213
214 def got_secret(self):
215 log.info("Client %s received its secret",
216 self.properties["Name"])
217
218 def need_approval(self, timeout, default):
219 if not default:
220 message = "Client %s needs approval within %f seconds"
221 else:
222 message = "Client %s will get its secret in %f seconds"
223 log.info(message, self.properties["Name"], timeout/1000)
224
225 def rejected(self, reason):
226 log.info("Client %s was rejected; reason: %s",
227 self.properties["Name"], reason)
228
229 def selectable(self):
230 """Make this a "selectable" widget.
231 This overrides the method from urwid.Widget."""
232 return True
233
234 def rows(self, maxcolrow, focus=False):
235 """How many rows this widget will occupy might depend on
236 whether we have focus or not.
237 This overrides the method from urwid.Widget"""
238 return self.current_widget(focus).rows(maxcolrow, focus=focus)
239
240 def current_widget(self, focus=False):
241 if focus or self.opened:
242 return self._focus_widget
243 return self._widget
244
245 def update(self):
246 "Called when what is visible on the screen should be updated."
247 # How to add standout mode to a style
248 with_standout = {"normal": "standout",
249 "bold": "bold-standout",
250 "underline-blink":
251 "underline-blink-standout",
252 "bold-underline-blink":
253 "bold-underline-blink-standout",
254 }
255
256 # Rebuild focus and non-focus widgets using current properties
257
258 # Base part of a client. Name!
259 base = "{name}: ".format(name=self.properties["Name"])
260 if not self.properties["Enabled"]:
261 message = "DISABLED"
262 self.using_timer(False)
263 elif self.properties["ApprovalPending"]:
264 timeout = datetime.timedelta(
265 milliseconds=self.properties["ApprovalDelay"])
266 last_approval_request = isoformat_to_datetime(
267 self.properties["LastApprovalRequest"])
268 if last_approval_request is not None:
269 timer = max(timeout - (datetime.datetime.utcnow()
270 - last_approval_request),
271 datetime.timedelta())
272 else:
273 timer = datetime.timedelta()
274 if self.properties["ApprovedByDefault"]:
275 message = "Approval in {}. (d)eny?"
276 else:
277 message = "Denial in {}. (a)pprove?"
278 message = message.format(str(timer).rsplit(".", 1)[0])
279 self.using_timer(True)
280 elif self.properties["LastCheckerStatus"] != 0:
281 # When checker has failed, show timer until client expires
282 expires = self.properties["Expires"]
283 if expires == "":
284 timer = datetime.timedelta(0)
285 else:
286 expires = (datetime.datetime.strptime
287 (expires, "%Y-%m-%dT%H:%M:%S.%f"))
288 timer = max(expires - datetime.datetime.utcnow(),
289 datetime.timedelta())
290 message = ("A checker has failed! Time until client"
291 " gets disabled: {}"
292 .format(str(timer).rsplit(".", 1)[0]))
293 self.using_timer(True)
294 else:
295 message = "enabled"
296 self.using_timer(False)
297 self._text = "{}{}".format(base, message)
298
299 if not urwid.supports_unicode():
300 self._text = self._text.encode("ascii", "replace")
301 textlist = [("normal", self._text)]
302 self._text_widget.set_text(textlist)
303 self._focus_text_widget.set_text([(with_standout[text[0]],
304 text[1])
305 if isinstance(text, tuple)
306 else text
307 for text in textlist])
308 self._widget = self._text_widget
309 self._focus_widget = urwid.AttrWrap(self._focus_text_widget,
310 "standout")
311 # Run update hook, if any
312 if self.update_hook is not None:
313 self.update_hook()
314
315 def update_timer(self):
316 """called by GLib. Will indefinitely loop until
317 GLib.source_remove() on tag is called
318 """
319 self.update()
320 return True # Keep calling this
321
322 def delete(self, **kwargs):
323 if self._update_timer_callback_tag is not None:
324 GLib.source_remove(self._update_timer_callback_tag)
325 self._update_timer_callback_tag = None
326 for match in self.match_objects:
327 match.remove()
328 self.match_objects = ()
329 if self.delete_hook is not None:
330 self.delete_hook(self)
331 return super(MandosClientWidget, self).delete(**kwargs)
332
333 def render(self, maxcolrow, focus=False):
334 """Render differently if we have focus.
335 This overrides the method from urwid.Widget"""
336 return self.current_widget(focus).render(maxcolrow,
337 focus=focus)
338
339 def keypress(self, maxcolrow, key):
340 """Handle keys.
341 This overrides the method from urwid.Widget"""
342 if key == "+":
343 self.proxy.Set(client_interface, "Enabled",
344 dbus.Boolean(True), ignore_reply=True,
345 dbus_interface=dbus.PROPERTIES_IFACE)
346 elif key == "-":
347 self.proxy.Set(client_interface, "Enabled", False,
348 ignore_reply=True,
349 dbus_interface=dbus.PROPERTIES_IFACE)
350 elif key == "a":
351 self.proxy.Approve(dbus.Boolean(True, variant_level=1),
352 dbus_interface=client_interface,
353 ignore_reply=True)
354 elif key == "d":
355 self.proxy.Approve(dbus.Boolean(False, variant_level=1),
356 dbus_interface=client_interface,
357 ignore_reply=True)
358 elif key == "R" or key == "_" or key == "ctrl k":
359 self.server_proxy_object.RemoveClient(self.proxy
360 .object_path,
361 ignore_reply=True)
362 elif key == "s":
363 self.proxy.Set(client_interface, "CheckerRunning",
364 dbus.Boolean(True), ignore_reply=True,
365 dbus_interface=dbus.PROPERTIES_IFACE)
366 elif key == "S":
367 self.proxy.Set(client_interface, "CheckerRunning",
368 dbus.Boolean(False), ignore_reply=True,
369 dbus_interface=dbus.PROPERTIES_IFACE)
370 elif key == "C":
371 self.proxy.CheckedOK(dbus_interface=client_interface,
372 ignore_reply=True)
373 # xxx
374 # elif key == "p" or key == "=":
375 # self.proxy.pause()
376 # elif key == "u" or key == ":":
377 # self.proxy.unpause()
378 # elif key == "RET":
379 # self.open()
380 else:
381 return key
382
383 def properties_changed(self, interface, properties, invalidated):
384 """Call self.update() if any properties changed.
385 This overrides the method from MandosClientPropertyCache"""
386 old_values = {key: self.properties.get(key)
387 for key in properties.keys()}
388 super(MandosClientWidget, self).properties_changed(
389 interface, properties, invalidated)
390 if any(old_values[key] != self.properties.get(key)
391 for key in old_values):
392 self.update()
393
394
395 def glib_safely(func, retval=True):
396 def safe_func(*args, **kwargs):
397 try:
398 return func(*args, **kwargs)
399 except Exception:
400 log.exception("")
401 return retval
402 return safe_func
403
404
405 class ConstrainedListBox(urwid.ListBox):
406 """Like a normal urwid.ListBox, but will consume all "up" or
407 "down" key presses, thus not allowing any containing widgets to
408 use them as an excuse to shift focus away from this widget.
409 """
410 def keypress(self, *args, **kwargs):
411 ret = (super(ConstrainedListBox, self)
412 .keypress(*args, **kwargs))
413 if ret in ("up", "down"):
414 return
415 return ret
416
417
418 class UserInterface:
419 """This is the entire user interface - the whole screen
420 with boxes, lists of client widgets, etc.
421 """
422 def __init__(self, max_log_length=1000):
423 DBusGMainLoop(set_as_default=True)
424
425 self.screen = urwid.curses_display.Screen()
426
427 self.screen.register_palette((
428 ("normal",
429 "default", "default", None),
430 ("bold",
431 "bold", "default", "bold"),
432 ("underline-blink",
433 "underline,blink", "default", "underline,blink"),
434 ("standout",
435 "standout", "default", "standout"),
436 ("bold-underline-blink",
437 "bold,underline,blink", "default",
438 "bold,underline,blink"),
439 ("bold-standout",
440 "bold,standout", "default", "bold,standout"),
441 ("underline-blink-standout",
442 "underline,blink,standout", "default",
443 "underline,blink,standout"),
444 ("bold-underline-blink-standout",
445 "bold,underline,blink,standout", "default",
446 "bold,underline,blink,standout"),
447 ))
448
449 if urwid.supports_unicode():
450 self.divider = "─" # \u2500
451 else:
452 self.divider = "_" # \u005f
453
454 self.screen.start()
455
456 self.size = self.screen.get_cols_rows()
457
458 self.clients = urwid.SimpleListWalker([])
459 self.clients_dict = {}
460
461 # We will add Text widgets to this list
462 self.log = urwid.SimpleListWalker([])
463 self.max_log_length = max_log_length
464
465 # We keep a reference to the log widget so we can remove it
466 # from the ListWalker without it getting destroyed
467 self.logbox = ConstrainedListBox(self.log)
468
469 # This keeps track of whether self.uilist currently has
470 # self.logbox in it or not
471 self.log_visible = True
472 self.log_wrap = "any"
473
474 self.loghandler = UILogHandler(self)
475
476 self.rebuild()
477 self.add_log_line(("bold",
478 "Mandos Monitor version " + version))
479 self.add_log_line(("bold", "q: Quit ?: Help"))
480
481 self.busname = domain + ".Mandos"
482 self.main_loop = GLib.MainLoop()
483
484 def client_not_found(self, key_id, address):
485 log.info("Client with address %s and key ID %s could"
486 " not be found", address, key_id)
487
488 def rebuild(self):
489 """This rebuilds the User Interface.
490 Call this when the widget layout needs to change"""
491 self.uilist = []
492 # self.uilist.append(urwid.ListBox(self.clients))
493 self.uilist.append(urwid.Frame(ConstrainedListBox(self.
494 clients),
495 # header=urwid.Divider(),
496 header=None,
497 footer=urwid.Divider(
498 div_char=self.divider)))
499 if self.log_visible:
500 self.uilist.append(self.logbox)
501 self.topwidget = urwid.Pile(self.uilist)
502
503 def add_log_line(self, markup):
504 self.log.append(urwid.Text(markup, wrap=self.log_wrap))
505 if self.max_log_length:
506 if len(self.log) > self.max_log_length:
507 del self.log[0:(len(self.log) - self.max_log_length)]
508 self.logbox.set_focus(len(self.logbox.body.contents)-1,
509 coming_from="above")
510 self.refresh()
511
512 def toggle_log_display(self):
513 """Toggle visibility of the log buffer."""
514 self.log_visible = not self.log_visible
515 self.rebuild()
516 log.debug("Log visibility changed to: %s", self.log_visible)
517
518 def change_log_display(self):
519 """Change type of log display.
520 Currently, this toggles wrapping of text lines."""
521 if self.log_wrap == "clip":
522 self.log_wrap = "any"
523 else:
524 self.log_wrap = "clip"
525 for textwidget in self.log:
526 textwidget.set_wrap_mode(self.log_wrap)
527 log.debug("Wrap mode: %s", self.log_wrap)
528
529 def find_and_remove_client(self, path, interfaces):
530 """Find a client by its object path and remove it.
531
532 This is connected to the InterfacesRemoved signal from the
533 Mandos server object."""
534 if client_interface not in interfaces:
535 # Not a Mandos client object; ignore
536 return
537 try:
538 client = self.clients_dict[path]
539 except KeyError:
540 # not found?
541 log.warning("Unknown client %s removed", path)
542 return
543 client.delete()
544
545 def add_new_client(self, path, ifs_and_props):
546 """Find a client by its object path and remove it.
547
548 This is connected to the InterfacesAdded signal from the
549 Mandos server object.
550 """
551 if client_interface not in ifs_and_props:
552 # Not a Mandos client object; ignore
553 return
554 client_proxy_object = self.bus.get_object(self.busname, path)
555 self.add_client(MandosClientWidget(
556 server_proxy_object=self.mandos_serv,
557 proxy_object=client_proxy_object,
558 update_hook=self.refresh,
559 delete_hook=self.remove_client,
560 properties=dict(ifs_and_props[client_interface])),
561 path=path)
562
563 def add_client(self, client, path=None):
564 self.clients.append(client)
565 if path is None:
566 path = client.proxy.object_path
567 self.clients_dict[path] = client
568 self.clients.sort(key=lambda c: c.properties["Name"])
569 self.refresh()
570
571 def remove_client(self, client, path=None):
572 self.clients.remove(client)
573 if path is None:
574 path = client.proxy.object_path
575 del self.clients_dict[path]
576 self.refresh()
577
578 def refresh(self):
579 """Redraw the screen"""
580 canvas = self.topwidget.render(self.size, focus=True)
581 self.screen.draw_screen(self.size, canvas)
582
583 def run(self):
584 """Start the main loop and exit when it's done."""
585 log.addHandler(self.loghandler)
586 self.orig_log_propagate = log.propagate
587 log.propagate = False
588 self.orig_log_level = log.level
589 log.setLevel("INFO")
590 self.bus = dbus.SystemBus()
591 mandos_dbus_objc = self.bus.get_object(
592 self.busname, "/", follow_name_owner_changes=True)
593 self.mandos_serv = dbus.Interface(
594 mandos_dbus_objc, dbus_interface=server_interface)
595 try:
596 mandos_clients = (self.mandos_serv
597 .GetAllClientsWithProperties())
598 if not mandos_clients:
599 log.warning("Note: Server has no clients.")
600 except dbus.exceptions.DBusException:
601 log.warning("Note: No Mandos server running.")
602 mandos_clients = dbus.Dictionary()
603
604 (self.mandos_serv
605 .connect_to_signal("InterfacesRemoved",
606 self.find_and_remove_client,
607 dbus_interface=dbus.OBJECT_MANAGER_IFACE,
608 byte_arrays=True))
609 (self.mandos_serv
610 .connect_to_signal("InterfacesAdded",
611 self.add_new_client,
612 dbus_interface=dbus.OBJECT_MANAGER_IFACE,
613 byte_arrays=True))
614 (self.mandos_serv
615 .connect_to_signal("ClientNotFound",
616 self.client_not_found,
617 dbus_interface=server_interface,
618 byte_arrays=True))
619 for path, client in mandos_clients.items():
620 client_proxy_object = self.bus.get_object(self.busname,
621 path)
622 self.add_client(MandosClientWidget(
623 server_proxy_object=self.mandos_serv,
624 proxy_object=client_proxy_object,
625 properties=client,
626 update_hook=self.refresh,
627 delete_hook=self.remove_client),
628 path=path)
629
630 self.refresh()
631 self._input_callback_tag = (
632 GLib.io_add_watch(
633 GLib.IOChannel.unix_new(sys.stdin.fileno()),
634 GLib.PRIORITY_DEFAULT, GLib.IO_IN,
635 glib_safely(self.process_input)))
636 self.main_loop.run()
637 # Main loop has finished, we should close everything now
638 GLib.source_remove(self._input_callback_tag)
639 with warnings.catch_warnings():
640 warnings.simplefilter("ignore", BytesWarning)
641 self.screen.stop()
642
643 def stop(self):
644 self.main_loop.quit()
645 log.removeHandler(self.loghandler)
646 log.propagate = self.orig_log_propagate
647
648 def process_input(self, source, condition):
649 keys = self.screen.get_input()
650 translations = {"ctrl n": "down", # Emacs
651 "ctrl p": "up", # Emacs
652 "ctrl v": "page down", # Emacs
653 "meta v": "page up", # Emacs
654 " ": "page down", # less
655 "f": "page down", # less
656 "b": "page up", # less
657 "j": "down", # vi
658 "k": "up", # vi
659 }
660 for key in keys:
661 try:
662 key = translations[key]
663 except KeyError: # :-)
664 pass
665
666 if key == "q" or key == "Q":
667 self.stop()
668 break
669 elif key == "window resize":
670 self.size = self.screen.get_cols_rows()
671 self.refresh()
672 elif key == "ctrl l":
673 self.screen.clear()
674 self.refresh()
675 elif key == "l" or key == "D":
676 self.toggle_log_display()
677 self.refresh()
678 elif key == "w" or key == "i":
679 self.change_log_display()
680 self.refresh()
681 elif key == "?" or key == "f1" or key == "esc":
682 if not self.log_visible:
683 self.log_visible = True
684 self.rebuild()
685 self.add_log_line(("bold",
686 " ".join(("q: Quit",
687 "?: Help",
688 "l: Log window toggle",
689 "TAB: Switch window",
690 "w: Wrap (log lines)",
691 "v: Toggle verbose log",
692 ))))
693 self.add_log_line(("bold",
694 " ".join(("Clients:",
695 "+: Enable",
696 "-: Disable",
697 "R: Remove",
698 "s: Start new checker",
699 "S: Stop checker",
700 "C: Checker OK",
701 "a: Approve",
702 "d: Deny",
703 ))))
704 self.refresh()
705 elif key == "tab":
706 if self.topwidget.get_focus() is self.logbox:
707 self.topwidget.set_focus(0)
708 else:
709 self.topwidget.set_focus(self.logbox)
710 self.refresh()
711 elif key == "v":
712 if log.level < logging.INFO:
713 log.setLevel(logging.INFO)
714 log.info("Verbose mode: Off")
715 else:
716 log.setLevel(logging.NOTSET)
717 log.info("Verbose mode: On")
718 # elif (key == "end" or key == "meta >" or key == "G"
719 # or key == ">"):
720 # pass # xxx end-of-buffer
721 # elif (key == "home" or key == "meta <" or key == "g"
722 # or key == "<"):
723 # pass # xxx beginning-of-buffer
724 # elif key == "ctrl e" or key == "$":
725 # pass # xxx move-end-of-line
726 # elif key == "ctrl a" or key == "^":
727 # pass # xxx move-beginning-of-line
728 # elif key == "ctrl b" or key == "meta (" or key == "h":
729 # pass # xxx left
730 # elif key == "ctrl f" or key == "meta )" or key == "l":
731 # pass # xxx right
732 # elif key == "a":
733 # pass # scroll up log
734 # elif key == "z":
735 # pass # scroll down log
736 elif self.topwidget.selectable():
737 self.topwidget.keypress(self.size, key)
738 self.refresh()
739 return True
740
741
742 class UILogHandler(logging.Handler):
743 def __init__(self, ui, *args, **kwargs):
744 self.ui = ui
745 super(UILogHandler, self).__init__(*args, **kwargs)
746 self.setFormatter(
747 logging.Formatter("%(asctime)s: %(message)s"))
748 def emit(self, record):
749 msg = self.format(record)
750 if record.levelno > logging.INFO:
751 msg = ("bold", msg)
752 self.ui.add_log_line(msg)
753
754
755 ui = UserInterface()
756 try:
757 ui.run()
758 except KeyboardInterrupt:
759 with warnings.catch_warnings():
760 warnings.filterwarnings("ignore", "", BytesWarning)
761 ui.screen.stop()
762 except Exception:
763 with warnings.catch_warnings():
764 warnings.filterwarnings("ignore", "", BytesWarning)
765 ui.screen.stop()
766 raise