1
#!/usr/bin/python3 -bbI
2
2
# -*- mode: python; coding: utf-8 -*-
4
# Mandos Monitor - Control and monitor the Mandos server
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
13
# the Free Software Foundation, either version 3 of the License, or
14
# (at your option) any later version.
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.
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/>.
24
# Contact the authors at <mandos@recompile.se>.
4
from __future__ import division, absolute_import, with_statement
27
from __future__ import (division, absolute_import, print_function,
30
from future_builtins import *
12
41
import urwid.curses_display
15
44
from dbus.mainloop.glib import DBusGMainLoop
45
from gi.repository import GLib
24
locale.setlocale(locale.LC_ALL, u'')
27
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
49
if sys.version_info.major == 2:
53
log = logging.getLogger(os.path.basename(sys.argv[0]))
54
logging.basicConfig(level="NOTSET", # Show all messages
55
format="%(message)s") # Show basic log messages
57
logging.captureWarnings(True) # Show warnings via the logging system
59
locale.setlocale(locale.LC_ALL, "")
61
logging.getLogger("dbus.proxies").setLevel(logging.CRITICAL)
29
63
# Some useful constants
30
domain = 'se.bsnet.fukt'
31
server_interface = domain + '.Mandos'
32
client_interface = domain + '.Mandos.Client'
35
# Always run in monochrome mode
36
urwid.curses_display.curses.has_colors = lambda : False
38
# Urwid doesn't support blinking, but we want it. Since we have no
39
# use for underline on its own, we make underline also always blink.
40
urwid.curses_display.curses.A_UNDERLINE |= (
41
urwid.curses_display.curses.A_BLINK)
43
class MandosClientPropertyCache(object):
64
domain = "se.recompile"
65
server_interface = domain + ".Mandos"
66
client_interface = domain + ".Mandos.Client"
70
dbus.OBJECT_MANAGER_IFACE
71
except AttributeError:
72
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
75
def isoformat_to_datetime(iso):
76
"Parse an ISO 8601 date string to a datetime.datetime()"
79
d, t = iso.split("T", 1)
80
year, month, day = d.split("-", 2)
81
hour, minute, second = t.split(":", 2)
82
second, fraction = divmod(float(second), 1)
83
return datetime.datetime(int(year),
88
int(second), # Whole seconds
89
int(fraction*1000000)) # Microseconds
92
class MandosClientPropertyCache:
44
93
"""This wraps a Mandos Client D-Bus proxy object, caches the
45
94
properties and calls a hook function when any of them are
48
def __init__(self, proxy_object=None, *args, **kwargs):
49
self.proxy = proxy_object # Mandos Client proxy object
51
self.properties = dict()
52
self.proxy.connect_to_signal(u"PropertyChanged",
53
self.property_changed,
57
self.properties.update(
58
self.proxy.GetAll(client_interface,
59
dbus_interface = dbus.PROPERTIES_IFACE))
60
super(MandosClientPropertyCache, self).__init__(
63
def property_changed(self, property=None, value=None):
64
"""This is called whenever we get a PropertyChanged signal
65
It updates the changed property in the "properties" dict.
97
def __init__(self, proxy_object=None, properties=None, **kwargs):
98
self.proxy = proxy_object # Mandos Client proxy object
99
self.properties = dict() if properties is None else properties
100
self.property_changed_match = (
101
self.proxy.connect_to_signal("PropertiesChanged",
102
self.properties_changed,
103
dbus.PROPERTIES_IFACE,
106
if properties is None:
107
self.properties.update(self.proxy.GetAll(
109
dbus_interface=dbus.PROPERTIES_IFACE))
111
super(MandosClientPropertyCache, self).__init__(**kwargs)
113
def properties_changed(self, interface, properties, invalidated):
114
"""This is called whenever we get a PropertiesChanged signal
115
It updates the changed properties in the "properties" dict.
67
117
# Update properties dict with new value
68
self.properties[property] = value
118
if interface == client_interface:
119
self.properties.update(properties)
122
self.property_changed_match.remove()
71
125
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
72
126
"""A Mandos Client which is visible on the screen.
75
129
def __init__(self, server_proxy_object=None, update_hook=None,
76
delete_hook=None, logger=None, *args, **kwargs):
130
delete_hook=None, **kwargs):
77
131
# Called on update
78
132
self.update_hook = update_hook
79
133
# Called on delete
80
134
self.delete_hook = delete_hook
81
135
# Mandos Server proxy object
82
136
self.server_proxy_object = server_proxy_object
138
self._update_timer_callback_tag = None
86
140
# The widget shown normally
87
self._text_widget = urwid.Text(u"")
141
self._text_widget = urwid.Text("")
88
142
# The widget shown when we have focus
89
self._focus_text_widget = urwid.Text(u"")
90
super(MandosClientWidget, self).__init__(
91
update_hook=update_hook, delete_hook=delete_hook,
143
self._focus_text_widget = urwid.Text("")
144
super(MandosClientWidget, self).__init__(**kwargs)
94
146
self.opened = False
95
self.proxy.connect_to_signal(u"CheckerCompleted",
96
self.checker_completed,
99
self.proxy.connect_to_signal(u"CheckerStarted",
100
self.checker_started,
103
self.proxy.connect_to_signal(u"GotSecret",
107
self.proxy.connect_to_signal(u"NeedApproval",
111
self.proxy.connect_to_signal(u"Rejected",
148
self.match_objects = (
149
self.proxy.connect_to_signal("CheckerCompleted",
150
self.checker_completed,
153
self.proxy.connect_to_signal("CheckerStarted",
154
self.checker_started,
157
self.proxy.connect_to_signal("GotSecret",
161
self.proxy.connect_to_signal("NeedApproval",
165
self.proxy.connect_to_signal("Rejected",
169
log.debug("Created client %s", self.properties["Name"])
171
def using_timer(self, flag):
172
"""Call this method with True or False when timer should be
173
activated or deactivated.
175
if flag and self._update_timer_callback_tag is None:
176
# Will update the shown timer value every second
177
self._update_timer_callback_tag = (
178
GLib.timeout_add(1000,
179
glib_safely(self.update_timer)))
180
elif not (flag or self._update_timer_callback_tag is None):
181
GLib.source_remove(self._update_timer_callback_tag)
182
self._update_timer_callback_tag = None
116
184
def checker_completed(self, exitstatus, condition, command):
117
185
if exitstatus == 0:
118
#self.logger(u'Checker for client %s (command "%s")'
120
# % (self.properties[u"name"], command))
186
log.debug('Checker for client %s (command "%s")'
187
" succeeded", self.properties["Name"], command)
122
191
if os.WIFEXITED(condition):
123
self.logger(u'Checker for client %s (command "%s")'
124
u' failed with exit code %s'
125
% (self.properties[u"name"], command,
126
os.WEXITSTATUS(condition)))
128
if os.WIFSIGNALED(condition):
129
self.logger(u'Checker for client %s (command "%s")'
130
u' was killed by signal %s'
131
% (self.properties[u"name"], command,
132
os.WTERMSIG(condition)))
134
if os.WCOREDUMP(condition):
135
self.logger(u'Checker for client %s (command "%s")'
137
% (self.properties[u"name"], command))
138
self.logger(u'Checker for client %s completed mysteriously')
192
log.info('Checker for client %s (command "%s") failed'
193
" with exit code %d", self.properties["Name"],
194
command, os.WEXITSTATUS(condition))
195
elif os.WIFSIGNALED(condition):
196
log.info('Checker for client %s (command "%s") was'
197
" killed by signal %d", self.properties["Name"],
198
command, os.WTERMSIG(condition))
140
201
def checker_started(self, command):
141
#self.logger(u'Client %s started checker "%s"'
142
# % (self.properties[u"name"], unicode(command)))
202
"""Server signals that a checker started."""
203
log.debug('Client %s started checker "%s"',
204
self.properties["Name"], command)
145
206
def got_secret(self):
146
self.logger(u'Client %s received its secret'
147
% self.properties[u"name"])
207
log.info("Client %s received its secret",
208
self.properties["Name"])
149
210
def need_approval(self, timeout, default):
151
message = u'Client %s needs approval within %s seconds'
212
message = "Client %s needs approval within %f seconds"
153
message = u'Client %s will get its secret in %s seconds'
155
% (self.properties[u"name"], timeout/1000))
214
message = "Client %s will get its secret in %f seconds"
215
log.info(message, self.properties["Name"], timeout/1000)
157
217
def rejected(self, reason):
158
self.logger(u'Client %s was rejected; reason: %s'
159
% (self.properties[u"name"], reason))
218
log.info("Client %s was rejected; reason: %s",
219
self.properties["Name"], reason)
161
221
def selectable(self):
162
222
"""Make this a "selectable" widget.
163
223
This overrides the method from urwid.FlowWidget."""
166
def rows(self, (maxcol,), focus=False):
226
def rows(self, maxcolrow, focus=False):
167
227
"""How many rows this widget will occupy might depend on
168
228
whether we have focus or not.
169
229
This overrides the method from urwid.FlowWidget"""
170
return self.current_widget(focus).rows((maxcol,), focus=focus)
230
return self.current_widget(focus).rows(maxcolrow, focus=focus)
172
232
def current_widget(self, focus=False):
173
233
if focus or self.opened:
174
234
return self._focus_widget
175
235
return self._widget
177
237
def update(self):
178
238
"Called when what is visible on the screen should be updated."
179
239
# How to add standout mode to a style
180
with_standout = { u"normal": u"standout",
181
u"bold": u"bold-standout",
183
u"underline-blink-standout",
184
u"bold-underline-blink":
185
u"bold-underline-blink-standout",
240
with_standout = {"normal": "standout",
241
"bold": "bold-standout",
243
"underline-blink-standout",
244
"bold-underline-blink":
245
"bold-underline-blink-standout",
188
248
# Rebuild focus and non-focus widgets using current properties
189
self._text = (u'%(name)s: %(enabled)s'
190
% { u"name": self.properties[u"name"],
193
if self.properties[u"enabled"]
250
# Base part of a client. Name!
251
base = "{name}: ".format(name=self.properties["Name"])
252
if not self.properties["Enabled"]:
254
self.using_timer(False)
255
elif self.properties["ApprovalPending"]:
256
timeout = datetime.timedelta(
257
milliseconds=self.properties["ApprovalDelay"])
258
last_approval_request = isoformat_to_datetime(
259
self.properties["LastApprovalRequest"])
260
if last_approval_request is not None:
261
timer = max(timeout - (datetime.datetime.utcnow()
262
- last_approval_request),
263
datetime.timedelta())
265
timer = datetime.timedelta()
266
if self.properties["ApprovedByDefault"]:
267
message = "Approval in {}. (d)eny?"
269
message = "Denial in {}. (a)pprove?"
270
message = message.format(str(timer).rsplit(".", 1)[0])
271
self.using_timer(True)
272
elif self.properties["LastCheckerStatus"] != 0:
273
# When checker has failed, show timer until client expires
274
expires = self.properties["Expires"]
276
timer = datetime.timedelta(0)
278
expires = (datetime.datetime.strptime
279
(expires, "%Y-%m-%dT%H:%M:%S.%f"))
280
timer = max(expires - datetime.datetime.utcnow(),
281
datetime.timedelta())
282
message = ("A checker has failed! Time until client"
284
.format(str(timer).rsplit(".", 1)[0]))
285
self.using_timer(True)
288
self.using_timer(False)
289
self._text = "{}{}".format(base, message)
195
291
if not urwid.supports_unicode():
196
292
self._text = self._text.encode("ascii", "replace")
197
textlist = [(u"normal", self._text)]
293
textlist = [("normal", self._text)]
198
294
self._text_widget.set_text(textlist)
199
295
self._focus_text_widget.set_text([(with_standout[text[0]],
207
303
# Run update hook, if any
208
304
if self.update_hook is not None:
209
305
self.update_hook()
307
def update_timer(self):
308
"""called by GLib. Will indefinitely loop until
309
GLib.source_remove() on tag is called
312
return True # Keep calling this
314
def delete(self, **kwargs):
315
if self._update_timer_callback_tag is not None:
316
GLib.source_remove(self._update_timer_callback_tag)
317
self._update_timer_callback_tag = None
318
for match in self.match_objects:
320
self.match_objects = ()
212
321
if self.delete_hook is not None:
213
322
self.delete_hook(self)
215
def render(self, (maxcol,), focus=False):
323
return super(MandosClientWidget, self).delete(**kwargs)
325
def render(self, maxcolrow, focus=False):
216
326
"""Render differently if we have focus.
217
327
This overrides the method from urwid.FlowWidget"""
218
return self.current_widget(focus).render((maxcol,),
328
return self.current_widget(focus).render(maxcolrow,
221
def keypress(self, (maxcol,), key):
331
def keypress(self, maxcolrow, key):
223
333
This overrides the method from urwid.FlowWidget"""
224
if key == u"e" or key == u"+":
226
elif key == u"d" or key == u"-":
228
elif key == u"r" or key == u"_" or key == u"ctrl k":
335
self.proxy.Set(client_interface, "Enabled",
336
dbus.Boolean(True), ignore_reply=True,
337
dbus_interface=dbus.PROPERTIES_IFACE)
339
self.proxy.Set(client_interface, "Enabled", False,
341
dbus_interface=dbus.PROPERTIES_IFACE)
343
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
344
dbus_interface=client_interface,
347
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
348
dbus_interface=client_interface,
350
elif key == "R" or key == "_" or key == "ctrl k":
229
351
self.server_proxy_object.RemoveClient(self.proxy
232
self.proxy.StartChecker()
234
self.proxy.StopChecker()
236
self.proxy.CheckedOK()
355
self.proxy.Set(client_interface, "CheckerRunning",
356
dbus.Boolean(True), ignore_reply=True,
357
dbus_interface=dbus.PROPERTIES_IFACE)
359
self.proxy.Set(client_interface, "CheckerRunning",
360
dbus.Boolean(False), ignore_reply=True,
361
dbus_interface=dbus.PROPERTIES_IFACE)
363
self.proxy.CheckedOK(dbus_interface=client_interface,
238
# elif key == u"p" or key == "=":
366
# elif key == "p" or key == "=":
239
367
# self.proxy.pause()
240
# elif key == u"u" or key == ":":
368
# elif key == "u" or key == ":":
241
369
# self.proxy.unpause()
242
# elif key == u"RET":
245
self.proxy.Approve(True)
247
self.proxy.Approve(False)
251
def property_changed(self, property=None, value=None,
253
"""Call self.update() if old value is not new value.
375
def properties_changed(self, interface, properties, invalidated):
376
"""Call self.update() if any properties changed.
254
377
This overrides the method from MandosClientPropertyCache"""
255
property_name = unicode(property)
256
old_value = self.properties.get(property_name)
257
super(MandosClientWidget, self).property_changed(
258
property=property, value=value, *args, **kwargs)
259
if self.properties.get(property_name) != old_value:
378
old_values = {key: self.properties.get(key)
379
for key in properties.keys()}
380
super(MandosClientWidget, self).properties_changed(
381
interface, properties, invalidated)
382
if any(old_values[key] != self.properties.get(key)
383
for key in old_values):
387
def glib_safely(func, retval=True):
388
def safe_func(*args, **kwargs):
390
return func(*args, **kwargs)
263
397
class ConstrainedListBox(urwid.ListBox):
264
398
"""Like a normal urwid.ListBox, but will consume all "up" or
265
399
"down" key presses, thus not allowing any containing widgets to
266
400
use them as an excuse to shift focus away from this widget.
268
def keypress(self, (maxcol, maxrow), key):
269
ret = super(ConstrainedListBox, self).keypress((maxcol, maxrow), key)
270
if ret in (u"up", u"down"):
402
def keypress(self, *args, **kwargs):
403
ret = (super(ConstrainedListBox, self)
404
.keypress(*args, **kwargs))
405
if ret in ("up", "down"):
275
class UserInterface(object):
276
411
"""This is the entire user interface - the whole screen
277
412
with boxes, lists of client widgets, etc.
279
414
def __init__(self, max_log_length=1000):
280
415
DBusGMainLoop(set_as_default=True)
282
417
self.screen = urwid.curses_display.Screen()
284
419
self.screen.register_palette((
286
u"default", u"default", None),
288
u"default", u"default", u"bold"),
290
u"default", u"default", u"underline"),
292
u"default", u"default", u"standout"),
293
(u"bold-underline-blink",
294
u"default", u"default", (u"bold", u"underline")),
296
u"default", u"default", (u"bold", u"standout")),
297
(u"underline-blink-standout",
298
u"default", u"default", (u"underline", u"standout")),
299
(u"bold-underline-blink-standout",
300
u"default", u"default", (u"bold", u"underline",
421
"default", "default", None),
423
"bold", "default", "bold"),
425
"underline,blink", "default", "underline,blink"),
427
"standout", "default", "standout"),
428
("bold-underline-blink",
429
"bold,underline,blink", "default",
430
"bold,underline,blink"),
432
"bold,standout", "default", "bold,standout"),
433
("underline-blink-standout",
434
"underline,blink,standout", "default",
435
"underline,blink,standout"),
436
("bold-underline-blink-standout",
437
"bold,underline,blink,standout", "default",
438
"bold,underline,blink,standout"),
304
441
if urwid.supports_unicode():
305
self.divider = u"─" # \u2500
306
#self.divider = u"━" # \u2501
442
self.divider = "─" # \u2500
308
#self.divider = u"-" # \u002d
309
self.divider = u"_" # \u005f
444
self.divider = "_" # \u005f
311
446
self.screen.start()
313
448
self.size = self.screen.get_cols_rows()
315
450
self.clients = urwid.SimpleListWalker([])
316
451
self.clients_dict = {}
318
453
# We will add Text widgets to this list
454
self.log = urwid.SimpleListWalker([])
320
455
self.max_log_length = max_log_length
322
457
# We keep a reference to the log widget so we can remove it
323
458
# from the ListWalker without it getting destroyed
324
459
self.logbox = ConstrainedListBox(self.log)
326
461
# This keeps track of whether self.uilist currently has
327
462
# self.logbox in it or not
328
463
self.log_visible = True
329
self.log_wrap = u"any"
464
self.log_wrap = "any"
466
self.loghandler = UILogHandler(self)
332
self.log_message_raw((u"bold",
333
u"Mandos Monitor version " + version))
334
self.log_message_raw((u"bold",
337
self.busname = domain + '.Mandos'
338
self.main_loop = gobject.MainLoop()
339
self.bus = dbus.SystemBus()
340
mandos_dbus_objc = self.bus.get_object(
341
self.busname, u"/", follow_name_owner_changes=True)
342
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
346
mandos_clients = (self.mandos_serv
347
.GetAllClientsWithProperties())
348
except dbus.exceptions.DBusException:
349
mandos_clients = dbus.Dictionary()
352
.connect_to_signal(u"ClientRemoved",
353
self.find_and_remove_client,
354
dbus_interface=server_interface,
357
.connect_to_signal(u"ClientAdded",
359
dbus_interface=server_interface,
362
.connect_to_signal(u"ClientNotFound",
363
self.client_not_found,
364
dbus_interface=server_interface,
366
for path, client in mandos_clients.iteritems():
367
client_proxy_object = self.bus.get_object(self.busname,
369
self.add_client(MandosClientWidget(server_proxy_object
372
=client_proxy_object,
382
def client_not_found(self, fingerprint, address):
383
self.log_message((u"Client with address %s and fingerprint %s"
384
u" could not be found" % (address,
469
self.add_log_line(("bold",
470
"Mandos Monitor version " + version))
471
self.add_log_line(("bold", "q: Quit ?: Help"))
473
self.busname = domain + ".Mandos"
474
self.main_loop = GLib.MainLoop()
476
def client_not_found(self, key_id, address):
477
log.info("Client with address %s and key ID %s could"
478
" not be found", address, key_id)
387
480
def rebuild(self):
388
481
"""This rebuilds the User Interface.
389
482
Call this when the widget layout needs to change"""
391
#self.uilist.append(urwid.ListBox(self.clients))
392
self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),
393
#header=urwid.Divider(),
484
# self.uilist.append(urwid.ListBox(self.clients))
485
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
487
# header=urwid.Divider(),
395
footer=urwid.Divider(div_char=self.divider)))
489
footer=urwid.Divider(
490
div_char=self.divider)))
396
491
if self.log_visible:
397
492
self.uilist.append(self.logbox)
399
493
self.topwidget = urwid.Pile(self.uilist)
401
def log_message(self, message):
402
timestamp = datetime.datetime.now().isoformat()
403
self.log_message_raw(timestamp + u": " + message)
405
def log_message_raw(self, markup):
406
"""Add a log message to the log buffer."""
495
def add_log_line(self, markup):
407
496
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
408
if (self.max_log_length
409
and len(self.log) > self.max_log_length):
410
del self.log[0:len(self.log)-self.max_log_length-1]
411
self.logbox.set_focus(len(self.logbox.body.contents),
412
coming_from=u"above")
497
if self.max_log_length:
498
if len(self.log) > self.max_log_length:
499
del self.log[0:(len(self.log) - self.max_log_length)]
500
self.logbox.set_focus(len(self.logbox.body.contents)-1,
415
504
def toggle_log_display(self):
416
505
"""Toggle visibility of the log buffer."""
417
506
self.log_visible = not self.log_visible
419
self.log_message(u"Log visibility changed to: "
420
+ unicode(self.log_visible))
508
log.debug("Log visibility changed to: %s", self.log_visible)
422
510
def change_log_display(self):
423
511
"""Change type of log display.
424
512
Currently, this toggles wrapping of text lines."""
425
if self.log_wrap == u"clip":
426
self.log_wrap = u"any"
513
if self.log_wrap == "clip":
514
self.log_wrap = "any"
428
self.log_wrap = u"clip"
516
self.log_wrap = "clip"
429
517
for textwidget in self.log:
430
518
textwidget.set_wrap_mode(self.log_wrap)
431
self.log_message(u"Wrap mode: " + self.log_wrap)
433
def find_and_remove_client(self, path, name):
434
"""Find an client from its object path and remove it.
436
This is connected to the ClientRemoved signal from the
519
log.debug("Wrap mode: %s", self.log_wrap)
521
def find_and_remove_client(self, path, interfaces):
522
"""Find a client by its object path and remove it.
524
This is connected to the InterfacesRemoved signal from the
437
525
Mandos server object."""
526
if client_interface not in interfaces:
527
# Not a Mandos client object; ignore
439
530
client = self.clients_dict[path]
443
self.remove_client(client, path)
445
def add_new_client(self, path):
533
log.warning("Unknown client %s removed", path)
537
def add_new_client(self, path, ifs_and_props):
538
"""Find a client by its object path and remove it.
540
This is connected to the InterfacesAdded signal from the
541
Mandos server object.
543
if client_interface not in ifs_and_props:
544
# Not a Mandos client object; ignore
446
546
client_proxy_object = self.bus.get_object(self.busname, path)
447
self.add_client(MandosClientWidget(server_proxy_object
450
=client_proxy_object,
547
self.add_client(MandosClientWidget(
548
server_proxy_object=self.mandos_serv,
549
proxy_object=client_proxy_object,
550
update_hook=self.refresh,
551
delete_hook=self.remove_client,
552
properties=dict(ifs_and_props[client_interface])),
459
555
def add_client(self, client, path=None):
460
556
self.clients.append(client)
462
558
path = client.proxy.object_path
463
559
self.clients_dict[path] = client
464
self.clients.sort(None, lambda c: c.properties[u"name"])
560
self.clients.sort(key=lambda c: c.properties["Name"])
467
563
def remove_client(self, client, path=None):
468
564
self.clients.remove(client)
470
566
path = client.proxy.object_path
471
567
del self.clients_dict[path]
472
if not self.clients_dict:
473
# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
474
# is completely emptied, we need to recreate it.
475
self.clients = urwid.SimpleListWalker([])
479
570
def refresh(self):
480
571
"""Redraw the screen"""
481
572
canvas = self.topwidget.render(self.size, focus=True)
482
573
self.screen.draw_screen(self.size, canvas)
485
576
"""Start the main loop and exit when it's done."""
577
log.addHandler(self.loghandler)
578
self.orig_log_propagate = log.propagate
579
log.propagate = False
580
self.orig_log_level = log.level
582
self.bus = dbus.SystemBus()
583
mandos_dbus_objc = self.bus.get_object(
584
self.busname, "/", follow_name_owner_changes=True)
585
self.mandos_serv = dbus.Interface(
586
mandos_dbus_objc, dbus_interface=server_interface)
588
mandos_clients = (self.mandos_serv
589
.GetAllClientsWithProperties())
590
if not mandos_clients:
591
log.warning("Note: Server has no clients.")
592
except dbus.exceptions.DBusException:
593
log.warning("Note: No Mandos server running.")
594
mandos_clients = dbus.Dictionary()
597
.connect_to_signal("InterfacesRemoved",
598
self.find_and_remove_client,
599
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
602
.connect_to_signal("InterfacesAdded",
604
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
607
.connect_to_signal("ClientNotFound",
608
self.client_not_found,
609
dbus_interface=server_interface,
611
for path, client in mandos_clients.items():
612
client_proxy_object = self.bus.get_object(self.busname,
614
self.add_client(MandosClientWidget(
615
server_proxy_object=self.mandos_serv,
616
proxy_object=client_proxy_object,
618
update_hook=self.refresh,
619
delete_hook=self.remove_client),
487
self._input_callback_tag = (gobject.io_add_watch
623
self._input_callback_tag = (
625
GLib.IOChannel.unix_new(sys.stdin.fileno()),
626
GLib.PRIORITY_DEFAULT, GLib.IO_IN,
627
glib_safely(self.process_input)))
491
628
self.main_loop.run()
492
629
# Main loop has finished, we should close everything now
493
gobject.source_remove(self._input_callback_tag)
630
GLib.source_remove(self._input_callback_tag)
631
with warnings.catch_warnings():
632
warnings.simplefilter("ignore", BytesWarning)
497
636
self.main_loop.quit()
637
log.removeHandler(self.loghandler)
638
log.propagate = self.orig_log_propagate
499
640
def process_input(self, source, condition):
500
641
keys = self.screen.get_input()
501
translations = { u"ctrl n": u"down", # Emacs
502
u"ctrl p": u"up", # Emacs
503
u"ctrl v": u"page down", # Emacs
504
u"meta v": u"page up", # Emacs
505
u" ": u"page down", # less
506
u"f": u"page down", # less
507
u"b": u"page up", # less
642
translations = {"ctrl n": "down", # Emacs
643
"ctrl p": "up", # Emacs
644
"ctrl v": "page down", # Emacs
645
"meta v": "page up", # Emacs
646
" ": "page down", # less
647
"f": "page down", # less
648
"b": "page up", # less
513
654
key = translations[key]
514
655
except KeyError: # :-)
517
if key == u"q" or key == u"Q":
658
if key == "q" or key == "Q":
520
elif key == u"window resize":
661
elif key == "window resize":
521
662
self.size = self.screen.get_cols_rows()
523
elif key == u"\f": # Ctrl-L
664
elif key == "ctrl l":
525
elif key == u"l" or key == u"D":
667
elif key == "l" or key == "D":
526
668
self.toggle_log_display()
528
elif key == u"w" or key == u"i":
670
elif key == "w" or key == "i":
529
671
self.change_log_display()
531
elif key == u"?" or key == u"f1" or key == u"esc":
673
elif key == "?" or key == "f1" or key == "esc":
532
674
if not self.log_visible:
533
675
self.log_visible = True
535
self.log_message_raw((u"bold",
539
u"l: Log window toggle",
540
u"TAB: Switch window",
542
self.log_message_raw((u"bold",
548
u"s: Start new checker",
677
self.add_log_line(("bold",
680
"l: Log window toggle",
681
"TAB: Switch window",
682
"w: Wrap (log lines)",
683
"v: Toggle verbose log",
685
self.add_log_line(("bold",
686
" ".join(("Clients:",
690
"s: Start new checker",
553
698
if self.topwidget.get_focus() is self.logbox:
554
699
self.topwidget.set_focus(0)
556
701
self.topwidget.set_focus(self.logbox)
558
#elif (key == u"end" or key == u"meta >" or key == u"G"
560
# pass # xxx end-of-buffer
561
#elif (key == u"home" or key == u"meta <" or key == u"g"
563
# pass # xxx beginning-of-buffer
564
#elif key == u"ctrl e" or key == u"$":
565
# pass # xxx move-end-of-line
566
#elif key == u"ctrl a" or key == u"^":
567
# pass # xxx move-beginning-of-line
568
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
570
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
573
# pass # scroll up log
575
# pass # scroll down log
704
if log.level < logging.INFO:
705
log.setLevel(logging.INFO)
706
log.info("Verbose mode: Off")
708
log.setLevel(logging.NOTSET)
709
log.info("Verbose mode: On")
710
# elif (key == "end" or key == "meta >" or key == "G"
712
# pass # xxx end-of-buffer
713
# elif (key == "home" or key == "meta <" or key == "g"
715
# pass # xxx beginning-of-buffer
716
# elif key == "ctrl e" or key == "$":
717
# pass # xxx move-end-of-line
718
# elif key == "ctrl a" or key == "^":
719
# pass # xxx move-beginning-of-line
720
# elif key == "ctrl b" or key == "meta (" or key == "h":
722
# elif key == "ctrl f" or key == "meta )" or key == "l":
725
# pass # scroll up log
727
# pass # scroll down log
576
728
elif self.topwidget.selectable():
577
729
self.topwidget.keypress(self.size, key)
734
class UILogHandler(logging.Handler):
735
def __init__(self, ui, *args, **kwargs):
737
super(UILogHandler, self).__init__(*args, **kwargs)
739
logging.Formatter("%(asctime)s: %(message)s"))
740
def emit(self, record):
741
msg = self.format(record)
742
if record.levelno > logging.INFO:
744
self.ui.add_log_line(msg)
581
747
ui = UserInterface()
585
ui.log_message(unicode(e))
750
except KeyboardInterrupt:
751
with warnings.catch_warnings():
752
warnings.filterwarnings("ignore", "", BytesWarning)
755
with warnings.catch_warnings():
756
warnings.filterwarnings("ignore", "", BytesWarning)