1
#!/usr/bin/python3 -bbI
2
2
# -*- mode: python; coding: utf-8 -*-
4
4
# Mandos Monitor - Control and monitor the Mandos server
6
# Copyright © 2009-2012 Teddy Hogeborn
7
# Copyright © 2009-2012 Björn Påhlsson
9
# This program is free software: you can redistribute it and/or modify
10
# it under the terms of the GNU General Public License as published by
6
# Copyright © 2009-2019 Teddy Hogeborn
7
# Copyright © 2009-2019 Björn Påhlsson
9
# This file is part of Mandos.
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
11
13
# the Free Software Foundation, either version 3 of the License, or
12
14
# (at your option) any later version.
14
# This program is distributed in the hope that it will be useful,
15
# but WITHOUT ANY WARRANTY; without even the implied warranty of
16
# Mandos is distributed in the hope that it will be useful, but
17
# WITHOUT ANY WARRANTY; without even the implied warranty of
16
18
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17
19
# GNU General Public License for more details.
19
21
# You should have received a copy of the GNU General Public License
20
# along with this program. If not, see
21
# <http://www.gnu.org/licenses/>.
22
# along with Mandos. If not, see <http://www.gnu.org/licenses/>.
23
24
# Contact the authors at <mandos@recompile.se>.
26
26
from __future__ import (division, absolute_import, print_function,
29
from future_builtins import *
30
from future_builtins import *
37
41
import urwid.curses_display
40
44
from dbus.mainloop.glib import DBusGMainLoop
45
from gi.repository import GLib
49
locale.setlocale(locale.LC_ALL, '')
52
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
49
if sys.version_info.major == 2:
54
# Show warnings by default
55
if not sys.warnoptions:
56
warnings.simplefilter("default")
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
62
logging.captureWarnings(True) # Show warnings via the logging system
64
locale.setlocale(locale.LC_ALL, "")
66
logging.getLogger("dbus.proxies").setLevel(logging.CRITICAL)
54
68
# Some useful constants
55
domain = 'se.recompile'
56
server_interface = domain + '.Mandos'
57
client_interface = domain + '.Mandos.Client'
60
# Always run in monochrome mode
61
urwid.curses_display.curses.has_colors = lambda : False
63
# Urwid doesn't support blinking, but we want it. Since we have no
64
# use for underline on its own, we make underline also always blink.
65
urwid.curses_display.curses.A_UNDERLINE |= (
66
urwid.curses_display.curses.A_BLINK)
69
domain = "se.recompile"
70
server_interface = domain + ".Mandos"
71
client_interface = domain + ".Mandos.Client"
75
dbus.OBJECT_MANAGER_IFACE
76
except AttributeError:
77
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
68
80
def isoformat_to_datetime(iso):
69
81
"Parse an ISO 8601 date string to a datetime.datetime()"
81
int(second), # Whole seconds
82
int(fraction*1000000)) # Microseconds
84
class MandosClientPropertyCache(object):
93
int(second), # Whole seconds
94
int(fraction*1000000)) # Microseconds
97
class MandosClientPropertyCache:
85
98
"""This wraps a Mandos Client D-Bus proxy object, caches the
86
99
properties and calls a hook function when any of them are
89
102
def __init__(self, proxy_object=None, properties=None, **kwargs):
90
self.proxy = proxy_object # Mandos Client proxy object
103
self.proxy = proxy_object # Mandos Client proxy object
91
104
self.properties = dict() if properties is None else properties
92
105
self.property_changed_match = (
93
self.proxy.connect_to_signal("PropertyChanged",
94
self._property_changed,
106
self.proxy.connect_to_signal("PropertiesChanged",
107
self.properties_changed,
108
dbus.PROPERTIES_IFACE,
96
109
byte_arrays=True))
98
111
if properties is None:
99
self.properties.update(
100
self.proxy.GetAll(client_interface,
102
= dbus.PROPERTIES_IFACE))
112
self.properties.update(self.proxy.GetAll(
114
dbus_interface=dbus.PROPERTIES_IFACE))
104
116
super(MandosClientPropertyCache, self).__init__(**kwargs)
106
def _property_changed(self, property, value):
107
"""Helper which takes positional arguments"""
108
return self.property_changed(property=property, value=value)
110
def property_changed(self, property=None, value=None):
111
"""This is called whenever we get a PropertyChanged signal
112
It updates the changed property in the "properties" dict.
118
def properties_changed(self, interface, properties, invalidated):
119
"""This is called whenever we get a PropertiesChanged signal
120
It updates the changed properties in the "properties" dict.
114
122
# Update properties dict with new value
115
self.properties[property] = value
123
if interface == client_interface:
124
self.properties.update(properties)
117
126
def delete(self):
118
127
self.property_changed_match.remove()
175
172
client_interface,
176
173
byte_arrays=True))
177
#self.logger('Created client {0}'
178
# .format(self.properties["Name"]))
180
def property_changed(self, property=None, value=None):
181
super(self, MandosClientWidget).property_changed(property,
183
if property == "ApprovalPending":
184
using_timer(bool(value))
185
if property == "LastCheckerStatus":
186
using_timer(value != 0)
187
#self.logger('Checker for client {0} (command "{1}") was '
188
# ' successful'.format(self.properties["Name"],
174
log.debug("Created client %s", self.properties["Name"])
191
176
def using_timer(self, flag):
192
177
"""Call this method with True or False when timer should be
193
178
activated or deactivated.
195
old = self._update_timer_callback_lock
197
self._update_timer_callback_lock += 1
199
self._update_timer_callback_lock -= 1
200
if old == 0 and self._update_timer_callback_lock:
180
if flag and self._update_timer_callback_tag is None:
201
181
# Will update the shown timer value every second
202
self._update_timer_callback_tag = (gobject.timeout_add
205
elif old and self._update_timer_callback_lock == 0:
206
gobject.source_remove(self._update_timer_callback_tag)
182
self._update_timer_callback_tag = (
183
GLib.timeout_add(1000,
184
glib_safely(self.update_timer)))
185
elif not (flag or self._update_timer_callback_tag is None):
186
GLib.source_remove(self._update_timer_callback_tag)
207
187
self._update_timer_callback_tag = None
209
189
def checker_completed(self, exitstatus, condition, command):
210
190
if exitstatus == 0:
191
log.debug('Checker for client %s (command "%s")'
192
" succeeded", self.properties["Name"], command)
214
196
if os.WIFEXITED(condition):
215
self.logger('Checker for client {0} (command "{1}")'
216
' failed with exit code {2}'
217
.format(self.properties["Name"], command,
218
os.WEXITSTATUS(condition)))
197
log.info('Checker for client %s (command "%s") failed'
198
" with exit code %d", self.properties["Name"],
199
command, os.WEXITSTATUS(condition))
219
200
elif os.WIFSIGNALED(condition):
220
self.logger('Checker for client {0} (command "{1}") was'
221
' killed by signal {2}'
222
.format(self.properties["Name"], command,
223
os.WTERMSIG(condition)))
224
elif os.WCOREDUMP(condition):
225
self.logger('Checker for client {0} (command "{1}")'
227
.format(self.properties["Name"], command))
229
self.logger('Checker for client {0} completed'
231
.format(self.properties["Name"]))
201
log.info('Checker for client %s (command "%s") was'
202
" killed by signal %d", self.properties["Name"],
203
command, os.WTERMSIG(condition))
234
206
def checker_started(self, command):
235
"""Server signals that a checker started. This could be useful
236
to log in the future. """
237
#self.logger('Client {0} started checker "{1}"'
238
# .format(self.properties["Name"],
207
"""Server signals that a checker started."""
208
log.debug('Client %s started checker "%s"',
209
self.properties["Name"], command)
242
211
def got_secret(self):
243
self.logger('Client {0} received its secret'
244
.format(self.properties["Name"]))
212
log.info("Client %s received its secret",
213
self.properties["Name"])
246
215
def need_approval(self, timeout, default):
248
message = 'Client {0} needs approval within {1} seconds'
217
message = "Client %s needs approval within %f seconds"
250
message = 'Client {0} will get its secret in {1} seconds'
251
self.logger(message.format(self.properties["Name"],
253
self.using_timer(True)
219
message = "Client %s will get its secret in %f seconds"
220
log.info(message, self.properties["Name"], timeout/1000)
255
222
def rejected(self, reason):
256
self.logger('Client {0} was rejected; reason: {1}'
257
.format(self.properties["Name"], reason))
223
log.info("Client %s was rejected; reason: %s",
224
self.properties["Name"], reason)
259
226
def selectable(self):
260
227
"""Make this a "selectable" widget.
261
228
This overrides the method from urwid.FlowWidget."""
264
231
def rows(self, maxcolrow, focus=False):
265
232
"""How many rows this widget will occupy might depend on
266
233
whether we have focus or not.
267
234
This overrides the method from urwid.FlowWidget"""
268
235
return self.current_widget(focus).rows(maxcolrow, focus=focus)
270
237
def current_widget(self, focus=False):
271
238
if focus or self.opened:
272
239
return self._focus_widget
273
240
return self._widget
275
242
def update(self):
276
243
"Called when what is visible on the screen should be updated."
277
244
# How to add standout mode to a style
278
with_standout = { "normal": "standout",
279
"bold": "bold-standout",
281
"underline-blink-standout",
282
"bold-underline-blink":
283
"bold-underline-blink-standout",
245
with_standout = {"normal": "standout",
246
"bold": "bold-standout",
248
"underline-blink-standout",
249
"bold-underline-blink":
250
"bold-underline-blink-standout",
286
253
# Rebuild focus and non-focus widgets using current properties
288
255
# Base part of a client. Name!
289
base = '{name}: '.format(name=self.properties["Name"])
256
base = "{name}: ".format(name=self.properties["Name"])
290
257
if not self.properties["Enabled"]:
291
258
message = "DISABLED"
259
self.using_timer(False)
292
260
elif self.properties["ApprovalPending"]:
293
timeout = datetime.timedelta(milliseconds
261
timeout = datetime.timedelta(
262
milliseconds=self.properties["ApprovalDelay"])
296
263
last_approval_request = isoformat_to_datetime(
297
264
self.properties["LastApprovalRequest"])
298
265
if last_approval_request is not None:
299
timer = timeout - (datetime.datetime.utcnow()
300
- last_approval_request)
266
timer = max(timeout - (datetime.datetime.utcnow()
267
- last_approval_request),
268
datetime.timedelta())
302
270
timer = datetime.timedelta()
303
271
if self.properties["ApprovedByDefault"]:
304
message = "Approval in {0}. (d)eny?"
272
message = "Approval in {}. (d)eny?"
306
message = "Denial in {0}. (a)pprove?"
307
message = message.format(unicode(timer).rsplit(".", 1)[0])
274
message = "Denial in {}. (a)pprove?"
275
message = message.format(str(timer).rsplit(".", 1)[0])
276
self.using_timer(True)
308
277
elif self.properties["LastCheckerStatus"] != 0:
309
278
# When checker has failed, show timer until client expires
310
279
expires = self.properties["Expires"]
353
326
if self.delete_hook is not None:
354
327
self.delete_hook(self)
355
328
return super(MandosClientWidget, self).delete(**kwargs)
357
330
def render(self, maxcolrow, focus=False):
358
331
"""Render differently if we have focus.
359
332
This overrides the method from urwid.FlowWidget"""
360
333
return self.current_widget(focus).render(maxcolrow,
363
336
def keypress(self, maxcolrow, key):
365
338
This overrides the method from urwid.FlowWidget"""
367
self.proxy.Enable(dbus_interface = client_interface,
340
self.proxy.Set(client_interface, "Enabled",
341
dbus.Boolean(True), ignore_reply=True,
342
dbus_interface=dbus.PROPERTIES_IFACE)
370
self.proxy.Disable(dbus_interface = client_interface,
344
self.proxy.Set(client_interface, "Enabled", False,
346
dbus_interface=dbus.PROPERTIES_IFACE)
373
348
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
374
dbus_interface = client_interface,
349
dbus_interface=client_interface,
375
350
ignore_reply=True)
377
352
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
378
dbus_interface = client_interface,
353
dbus_interface=client_interface,
379
354
ignore_reply=True)
380
355
elif key == "R" or key == "_" or key == "ctrl k":
381
356
self.server_proxy_object.RemoveClient(self.proxy
383
358
ignore_reply=True)
385
self.proxy.StartChecker(dbus_interface = client_interface,
360
self.proxy.Set(client_interface, "CheckerRunning",
361
dbus.Boolean(True), ignore_reply=True,
362
dbus_interface=dbus.PROPERTIES_IFACE)
388
self.proxy.StopChecker(dbus_interface = client_interface,
364
self.proxy.Set(client_interface, "CheckerRunning",
365
dbus.Boolean(False), ignore_reply=True,
366
dbus_interface=dbus.PROPERTIES_IFACE)
391
self.proxy.CheckedOK(dbus_interface = client_interface,
368
self.proxy.CheckedOK(dbus_interface=client_interface,
392
369
ignore_reply=True)
394
371
# elif key == "p" or key == "=":
403
def property_changed(self, property=None, **kwargs):
404
"""Call self.update() if old value is not new value.
380
def properties_changed(self, interface, properties, invalidated):
381
"""Call self.update() if any properties changed.
405
382
This overrides the method from MandosClientPropertyCache"""
406
property_name = unicode(property)
407
old_value = self.properties.get(property_name)
408
super(MandosClientWidget, self).property_changed(
409
property=property, **kwargs)
410
if self.properties.get(property_name) != old_value:
383
old_values = {key: self.properties.get(key)
384
for key in properties.keys()}
385
super(MandosClientWidget, self).properties_changed(
386
interface, properties, invalidated)
387
if any(old_values[key] != self.properties.get(key)
388
for key in old_values):
392
def glib_safely(func, retval=True):
393
def safe_func(*args, **kwargs):
395
return func(*args, **kwargs)
414
402
class ConstrainedListBox(urwid.ListBox):
415
403
"""Like a normal urwid.ListBox, but will consume all "up" or
416
404
"down" key presses, thus not allowing any containing widgets to
417
405
use them as an excuse to shift focus away from this widget.
419
407
def keypress(self, *args, **kwargs):
420
ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
408
ret = (super(ConstrainedListBox, self)
409
.keypress(*args, **kwargs))
421
410
if ret in ("up", "down"):
426
class UserInterface(object):
427
416
"""This is the entire user interface - the whole screen
428
417
with boxes, lists of client widgets, etc.
430
419
def __init__(self, max_log_length=1000):
431
420
DBusGMainLoop(set_as_default=True)
433
422
self.screen = urwid.curses_display.Screen()
435
424
self.screen.register_palette((
437
426
"default", "default", None),
439
"default", "default", "bold"),
428
"bold", "default", "bold"),
440
429
("underline-blink",
441
"default", "default", "underline"),
430
"underline,blink", "default", "underline,blink"),
443
"default", "default", "standout"),
432
"standout", "default", "standout"),
444
433
("bold-underline-blink",
445
"default", "default", ("bold", "underline")),
434
"bold,underline,blink", "default",
435
"bold,underline,blink"),
446
436
("bold-standout",
447
"default", "default", ("bold", "standout")),
437
"bold,standout", "default", "bold,standout"),
448
438
("underline-blink-standout",
449
"default", "default", ("underline", "standout")),
439
"underline,blink,standout", "default",
440
"underline,blink,standout"),
450
441
("bold-underline-blink-standout",
451
"default", "default", ("bold", "underline",
442
"bold,underline,blink,standout", "default",
443
"bold,underline,blink,standout"),
455
446
if urwid.supports_unicode():
456
self.divider = "─" # \u2500
457
#self.divider = "━" # \u2501
447
self.divider = "─" # \u2500
459
#self.divider = "-" # \u002d
460
self.divider = "_" # \u005f
449
self.divider = "_" # \u005f
462
451
self.screen.start()
464
453
self.size = self.screen.get_cols_rows()
466
455
self.clients = urwid.SimpleListWalker([])
467
456
self.clients_dict = {}
469
458
# We will add Text widgets to this list
459
self.log = urwid.SimpleListWalker([])
471
460
self.max_log_length = max_log_length
473
462
# We keep a reference to the log widget so we can remove it
474
463
# from the ListWalker without it getting destroyed
475
464
self.logbox = ConstrainedListBox(self.log)
477
466
# This keeps track of whether self.uilist currently has
478
467
# self.logbox in it or not
479
468
self.log_visible = True
480
469
self.log_wrap = "any"
471
self.loghandler = UILogHandler(self)
483
self.log_message_raw(("bold",
484
"Mandos Monitor version " + version))
485
self.log_message_raw(("bold",
488
self.busname = domain + '.Mandos'
489
self.main_loop = gobject.MainLoop()
491
def client_not_found(self, fingerprint, address):
492
self.log_message("Client with address {0} and fingerprint"
493
" {1} could not be found"
494
.format(address, fingerprint))
474
self.add_log_line(("bold",
475
"Mandos Monitor version " + version))
476
self.add_log_line(("bold", "q: Quit ?: Help"))
478
self.busname = domain + ".Mandos"
479
self.main_loop = GLib.MainLoop()
481
def client_not_found(self, key_id, address):
482
log.info("Client with address %s and key ID %s could"
483
" not be found", address, key_id)
496
485
def rebuild(self):
497
486
"""This rebuilds the User Interface.
498
487
Call this when the widget layout needs to change"""
500
#self.uilist.append(urwid.ListBox(self.clients))
489
# self.uilist.append(urwid.ListBox(self.clients))
501
490
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
503
#header=urwid.Divider(),
492
# header=urwid.Divider(),
506
urwid.Divider(div_char=
494
footer=urwid.Divider(
495
div_char=self.divider)))
508
496
if self.log_visible:
509
497
self.uilist.append(self.logbox)
510
498
self.topwidget = urwid.Pile(self.uilist)
512
def log_message(self, message):
513
timestamp = datetime.datetime.now().isoformat()
514
self.log_message_raw(timestamp + ": " + message)
516
def log_message_raw(self, markup):
517
"""Add a log message to the log buffer."""
500
def add_log_line(self, markup):
518
501
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
519
if (self.max_log_length
520
and len(self.log) > self.max_log_length):
521
del self.log[0:len(self.log)-self.max_log_length-1]
522
self.logbox.set_focus(len(self.logbox.body.contents),
502
if self.max_log_length:
503
if len(self.log) > self.max_log_length:
504
del self.log[0:(len(self.log) - self.max_log_length)]
505
self.logbox.set_focus(len(self.logbox.body.contents)-1,
523
506
coming_from="above")
526
509
def toggle_log_display(self):
527
510
"""Toggle visibility of the log buffer."""
528
511
self.log_visible = not self.log_visible
530
#self.log_message("Log visibility changed to: "
531
# + unicode(self.log_visible))
513
log.debug("Log visibility changed to: %s", self.log_visible)
533
515
def change_log_display(self):
534
516
"""Change type of log display.
535
517
Currently, this toggles wrapping of text lines."""
539
521
self.log_wrap = "clip"
540
522
for textwidget in self.log:
541
523
textwidget.set_wrap_mode(self.log_wrap)
542
#self.log_message("Wrap mode: " + self.log_wrap)
544
def find_and_remove_client(self, path, name):
524
log.debug("Wrap mode: %s", self.log_wrap)
526
def find_and_remove_client(self, path, interfaces):
545
527
"""Find a client by its object path and remove it.
547
This is connected to the ClientRemoved signal from the
529
This is connected to the InterfacesRemoved signal from the
548
530
Mandos server object."""
531
if client_interface not in interfaces:
532
# Not a Mandos client object; ignore
550
535
client = self.clients_dict[path]
553
self.log_message("Unknown client {0!r} ({1!r}) removed"
538
log.warning("Unknown client %s removed", path)
558
def add_new_client(self, path):
542
def add_new_client(self, path, ifs_and_props):
543
"""Find a client by its object path and remove it.
545
This is connected to the InterfacesAdded signal from the
546
Mandos server object.
548
if client_interface not in ifs_and_props:
549
# Not a Mandos client object; ignore
559
551
client_proxy_object = self.bus.get_object(self.busname, path)
560
self.add_client(MandosClientWidget(server_proxy_object
563
=client_proxy_object,
552
self.add_client(MandosClientWidget(
553
server_proxy_object=self.mandos_serv,
554
proxy_object=client_proxy_object,
555
update_hook=self.refresh,
556
delete_hook=self.remove_client,
557
properties=dict(ifs_and_props[client_interface])),
572
560
def add_client(self, client, path=None):
573
561
self.clients.append(client)
575
563
path = client.proxy.object_path
576
564
self.clients_dict[path] = client
577
self.clients.sort(None, lambda c: c.properties["Name"])
565
self.clients.sort(key=lambda c: c.properties["Name"])
580
568
def remove_client(self, client, path=None):
581
569
self.clients.remove(client)
583
571
path = client.proxy.object_path
584
572
del self.clients_dict[path]
585
if not self.clients_dict:
586
# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
587
# is completely emptied, we need to recreate it.
588
self.clients = urwid.SimpleListWalker([])
592
575
def refresh(self):
593
576
"""Redraw the screen"""
594
577
canvas = self.topwidget.render(self.size, focus=True)
595
578
self.screen.draw_screen(self.size, canvas)
598
581
"""Start the main loop and exit when it's done."""
582
log.addHandler(self.loghandler)
583
self.orig_log_propagate = log.propagate
584
log.propagate = False
585
self.orig_log_level = log.level
599
587
self.bus = dbus.SystemBus()
600
588
mandos_dbus_objc = self.bus.get_object(
601
589
self.busname, "/", follow_name_owner_changes=True)
602
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
590
self.mandos_serv = dbus.Interface(
591
mandos_dbus_objc, dbus_interface=server_interface)
606
593
mandos_clients = (self.mandos_serv
607
594
.GetAllClientsWithProperties())
595
if not mandos_clients:
596
log.warning("Note: Server has no clients.")
608
597
except dbus.exceptions.DBusException:
598
log.warning("Note: No Mandos server running.")
609
599
mandos_clients = dbus.Dictionary()
611
601
(self.mandos_serv
612
.connect_to_signal("ClientRemoved",
602
.connect_to_signal("InterfacesRemoved",
613
603
self.find_and_remove_client,
614
dbus_interface=server_interface,
604
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
615
605
byte_arrays=True))
616
606
(self.mandos_serv
617
.connect_to_signal("ClientAdded",
607
.connect_to_signal("InterfacesAdded",
618
608
self.add_new_client,
619
dbus_interface=server_interface,
609
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
620
610
byte_arrays=True))
621
611
(self.mandos_serv
622
612
.connect_to_signal("ClientNotFound",
623
613
self.client_not_found,
624
614
dbus_interface=server_interface,
625
615
byte_arrays=True))
626
for path, client in mandos_clients.iteritems():
616
for path, client in mandos_clients.items():
627
617
client_proxy_object = self.bus.get_object(self.busname,
629
self.add_client(MandosClientWidget(server_proxy_object
632
=client_proxy_object,
619
self.add_client(MandosClientWidget(
620
server_proxy_object=self.mandos_serv,
621
proxy_object=client_proxy_object,
623
update_hook=self.refresh,
624
delete_hook=self.remove_client),
643
self._input_callback_tag = (gobject.io_add_watch
628
self._input_callback_tag = (
630
GLib.IOChannel.unix_new(sys.stdin.fileno()),
631
GLib.PRIORITY_DEFAULT, GLib.IO_IN,
632
glib_safely(self.process_input)))
647
633
self.main_loop.run()
648
634
# Main loop has finished, we should close everything now
649
gobject.source_remove(self._input_callback_tag)
635
GLib.source_remove(self._input_callback_tag)
636
with warnings.catch_warnings():
637
warnings.simplefilter("ignore", BytesWarning)
653
641
self.main_loop.quit()
642
log.removeHandler(self.loghandler)
643
log.propagate = self.orig_log_propagate
655
645
def process_input(self, source, condition):
656
646
keys = self.screen.get_input()
657
translations = { "ctrl n": "down", # Emacs
658
"ctrl p": "up", # Emacs
659
"ctrl v": "page down", # Emacs
660
"meta v": "page up", # Emacs
661
" ": "page down", # less
662
"f": "page down", # less
663
"b": "page up", # less
647
translations = {"ctrl n": "down", # Emacs
648
"ctrl p": "up", # Emacs
649
"ctrl v": "page down", # Emacs
650
"meta v": "page up", # Emacs
651
" ": "page down", # less
652
"f": "page down", # less
653
"b": "page up", # less
669
659
key = translations[key]
670
660
except KeyError: # :-)
673
663
if key == "q" or key == "Q":
676
666
elif key == "window resize":
677
667
self.size = self.screen.get_cols_rows()
679
elif key == "\f": # Ctrl-L
669
elif key == "ctrl l":
681
672
elif key == "l" or key == "D":
682
673
self.toggle_log_display()
714
706
self.topwidget.set_focus(self.logbox)
716
#elif (key == "end" or key == "meta >" or key == "G"
718
# pass # xxx end-of-buffer
719
#elif (key == "home" or key == "meta <" or key == "g"
721
# pass # xxx beginning-of-buffer
722
#elif key == "ctrl e" or key == "$":
723
# pass # xxx move-end-of-line
724
#elif key == "ctrl a" or key == "^":
725
# pass # xxx move-beginning-of-line
726
#elif key == "ctrl b" or key == "meta (" or key == "h":
728
#elif key == "ctrl f" or key == "meta )" or key == "l":
731
# pass # scroll up log
733
# pass # scroll down log
709
if log.level < logging.INFO:
710
log.setLevel(logging.INFO)
711
log.info("Verbose mode: Off")
713
log.setLevel(logging.NOTSET)
714
log.info("Verbose mode: On")
715
# elif (key == "end" or key == "meta >" or key == "G"
717
# pass # xxx end-of-buffer
718
# elif (key == "home" or key == "meta <" or key == "g"
720
# pass # xxx beginning-of-buffer
721
# elif key == "ctrl e" or key == "$":
722
# pass # xxx move-end-of-line
723
# elif key == "ctrl a" or key == "^":
724
# pass # xxx move-beginning-of-line
725
# elif key == "ctrl b" or key == "meta (" or key == "h":
727
# elif key == "ctrl f" or key == "meta )" or key == "l":
730
# pass # scroll up log
732
# pass # scroll down log
734
733
elif self.topwidget.selectable():
735
734
self.topwidget.keypress(self.size, key)
739
class UILogHandler(logging.Handler):
740
def __init__(self, ui, *args, **kwargs):
742
super(UILogHandler, self).__init__(*args, **kwargs)
744
logging.Formatter("%(asctime)s: %(message)s"))
745
def emit(self, record):
746
msg = self.format(record)
747
if record.levelno > logging.INFO:
749
self.ui.add_log_line(msg)
739
752
ui = UserInterface()
742
755
except KeyboardInterrupt:
745
ui.log_message(unicode(e))
756
with warnings.catch_warnings():
757
warnings.filterwarnings("ignore", "", BytesWarning)
760
with warnings.catch_warnings():
761
warnings.filterwarnings("ignore", "", BytesWarning)