40
30
urwid.curses_display.curses.A_UNDERLINE |= (
41
31
urwid.curses_display.curses.A_BLINK)
43
def isoformat_to_datetime(iso):
44
"Parse an ISO 8601 date string to a datetime.datetime()"
47
d, t = iso.split(u"T", 1)
48
year, month, day = d.split(u"-", 2)
49
hour, minute, second = t.split(u":", 2)
50
second, fraction = divmod(float(second), 1)
51
return datetime.datetime(int(year),
56
int(second), # Whole seconds
57
int(fraction*1000000)) # Microseconds
59
33
class MandosClientPropertyCache(object):
60
34
"""This wraps a Mandos Client D-Bus proxy object, caches the
61
35
properties and calls a hook function when any of them are
64
def __init__(self, proxy_object=None, *args, **kwargs):
38
def __init__(self, proxy_object=None, properties=None, *args,
40
# Type conversion mapping
42
dbus.ObjectPath: unicode,
44
dbus.Signature: unicode,
52
dbus.Dictionary: dict,
65
59
self.proxy = proxy_object # Mandos Client proxy object
67
self.properties = dict()
68
self.proxy.connect_to_signal(u"PropertyChanged",
61
if properties is None:
62
self.properties = dict()
64
self.properties = dict(self.convert_property(prop, val)
66
properties.iteritems())
67
self.proxy.connect_to_signal("PropertyChanged",
69
68
self.property_changed,
73
self.properties.update(
74
self.proxy.GetAll(client_interface,
75
dbus_interface = dbus.PROPERTIES_IFACE))
77
#XXX This break good super behaviour!
78
# super(MandosClientPropertyCache, self).__init__(
72
if properties is None:
73
self.properties.update(
74
self.convert_property(prop, val)
76
self.proxy.GetAll(client_interface,
78
dbus.PROPERTIES_IFACE).iteritems())
79
super(MandosClientPropertyCache, self).__init__(
80
proxy_object=proxy_object,
81
properties=properties, *args, **kwargs)
83
def convert_property(self, property, value):
84
"""This converts the arguments from a D-Bus signal, which are
85
D-Bus types, into normal Python types, using a conversion
86
function from "self.type_map".
88
property_name = unicode(property) # Always a dbus.String
89
if isinstance(value, dbus.UTF8String):
90
# Should not happen, but prepare for it anyway
91
value = dbus.String(str(value).decode("utf-8"))
93
convfunc = self.type_map[type(value)]
95
# Unknown type, return unmodified
96
return property_name, value
97
return property_name, convfunc(value)
81
98
def property_changed(self, property=None, value=None):
82
99
"""This is called whenever we get a PropertyChanged signal
83
100
It updates the changed property in the "properties" dict.
102
# Convert name and value
103
property_name, cvalue = self.convert_property(property, value)
85
104
# Update properties dict with new value
86
self.properties[property] = value
105
self.properties[property_name] = cvalue
89
108
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
93
112
def __init__(self, server_proxy_object=None, update_hook=None,
94
delete_hook=None, logger=None, *args, **kwargs):
113
delete_hook=None, *args, **kwargs):
95
114
# Called on update
96
115
self.update_hook = update_hook
97
116
# Called on delete
98
117
self.delete_hook = delete_hook
99
118
# Mandos Server proxy object
100
119
self.server_proxy_object = server_proxy_object
104
self._update_timer_callback_tag = None
105
self.last_checker_failed = False
107
121
# The widget shown normally
108
self._text_widget = urwid.Text(u"")
122
self._text_widget = urwid.Text("")
109
123
# The widget shown when we have focus
110
self._focus_text_widget = urwid.Text(u"")
124
self._focus_text_widget = urwid.Text("")
111
125
super(MandosClientWidget, self).__init__(
112
126
update_hook=update_hook, delete_hook=delete_hook,
115
129
self.opened = False
116
self.proxy.connect_to_signal(u"CheckerCompleted",
117
self.checker_completed,
120
self.proxy.connect_to_signal(u"CheckerStarted",
121
self.checker_started,
124
self.proxy.connect_to_signal(u"GotSecret",
128
self.proxy.connect_to_signal(u"NeedApproval",
132
self.proxy.connect_to_signal(u"Rejected",
136
last_checked_ok = isoformat_to_datetime(self.properties
138
if last_checked_ok is None:
139
self.last_checker_failed = True
141
self.last_checker_failed = ((datetime.datetime.utcnow()
147
if self.last_checker_failed:
148
self._update_timer_callback_tag = (gobject.timeout_add
152
def checker_completed(self, exitstatus, condition, command):
154
if self.last_checker_failed:
155
self.last_checker_failed = False
156
gobject.source_remove(self._update_timer_callback_tag)
157
self._update_timer_callback_tag = None
158
#self.logger(u'Checker for client %s (command "%s")'
160
# % (self.properties[u"Name"], command))
164
if not self.last_checker_failed:
165
self.last_checker_failed = True
166
self._update_timer_callback_tag = (gobject.timeout_add
169
if os.WIFEXITED(condition):
170
self.logger(u'Checker for client %s (command "%s")'
171
u' failed with exit code %s'
172
% (self.properties[u"Name"], command,
173
os.WEXITSTATUS(condition)))
174
elif os.WIFSIGNALED(condition):
175
self.logger(u'Checker for client %s (command "%s")'
176
u' was killed by signal %s'
177
% (self.properties[u"Name"], command,
178
os.WTERMSIG(condition)))
179
elif os.WCOREDUMP(condition):
180
self.logger(u'Checker for client %s (command "%s")'
182
% (self.properties[u"Name"], command))
184
self.logger(u'Checker for client %s completed'
188
def checker_started(self, command):
189
#self.logger(u'Client %s started checker "%s"'
190
# % (self.properties[u"Name"], unicode(command)))
193
def got_secret(self):
194
self.last_checker_failed = False
195
self.logger(u'Client %s received its secret'
196
% self.properties[u"Name"])
198
def need_approval(self, timeout, default):
200
message = u'Client %s needs approval within %s seconds'
202
message = u'Client %s will get its secret in %s seconds'
204
% (self.properties[u"Name"], timeout/1000))
206
def rejected(self, reason):
207
self.logger(u'Client %s was rejected; reason: %s'
208
% (self.properties[u"Name"], reason))
210
131
def selectable(self):
211
132
"""Make this a "selectable" widget.
233
154
u"bold-underline-blink":
234
155
u"bold-underline-blink-standout",
237
158
# Rebuild focus and non-focus widgets using current properties
239
# Base part of a client. Name!
240
base = (u'%(name)s: '
241
% {u"name": self.properties[u"Name"]})
242
if not self.properties[u"Enabled"]:
243
message = u"DISABLED"
244
elif self.properties[u"ApprovalPending"]:
245
if self.properties[u"ApprovedByDefault"]:
246
message = u"Connection established to client. (d)eny?"
248
message = u"Seeks approval to send secret. (a)pprove?"
249
elif self.last_checker_failed:
250
timeout = datetime.timedelta(milliseconds
253
last_ok = isoformat_to_datetime(
254
max((self.properties[u"LastCheckedOK"]
255
or self.properties[u"Created"]),
256
self.properties[u"LastEnabled"]))
257
timer = timeout - (datetime.datetime.utcnow() - last_ok)
258
message = (u'A checker has failed! Time until client'
260
% unicode(timer).rsplit(".", 1)[0])
263
self._text = "%s%s" % (base, message)
159
self._text = (u'name="%(name)s", enabled=%(enabled)s'
265
161
if not urwid.supports_unicode():
266
162
self._text = self._text.encode("ascii", "replace")
267
textlist = [(u"normal", self._text)]
163
textlist = [(u"normal", u"BLÄRGH: "), (u"bold", self._text)]
268
164
self._text_widget.set_text(textlist)
269
165
self._focus_text_widget.set_text([(with_standout[text[0]],
299
187
def keypress(self, (maxcol,), key):
301
189
This overrides the method from urwid.FlowWidget"""
303
self.proxy.Enable(dbus_interface = client_interface)
305
self.proxy.Disable(dbus_interface = client_interface)
307
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
308
dbus_interface = client_interface)
310
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
311
dbus_interface = client_interface)
312
elif key == u"r" or key == u"_" or key == u"ctrl k":
190
if key == u"e" or key == u"+":
192
elif key == u"d" or key == u"-":
194
elif key == u"r" or key == u"_":
313
195
self.server_proxy_object.RemoveClient(self.proxy
315
197
elif key == u"s":
316
self.proxy.StartChecker(dbus_interface = client_interface)
198
self.proxy.StartChecker()
200
self.proxy.StopChecker()
317
201
elif key == u"S":
318
self.proxy.StopChecker(dbus_interface = client_interface)
320
self.proxy.CheckedOK(dbus_interface = client_interface)
202
self.proxy.CheckedOK()
322
204
# elif key == u"p" or key == "=":
323
205
# self.proxy.pause()
343
class ConstrainedListBox(urwid.ListBox):
344
"""Like a normal urwid.ListBox, but will consume all "up" or
345
"down" key presses, thus not allowing any containing widgets to
346
use them as an excuse to shift focus away from this widget.
348
def keypress(self, (maxcol, maxrow), key):
349
ret = super(ConstrainedListBox, self).keypress((maxcol,
351
if ret in (u"up", u"down"):
356
225
class UserInterface(object):
357
226
"""This is the entire user interface - the whole screen
358
227
with boxes, lists of client widgets, etc.
360
def __init__(self, max_log_length=1000):
361
DBusGMainLoop(set_as_default=True)
230
DBusGMainLoop(set_as_default=True )
363
232
self.screen = urwid.curses_display.Screen()
385
if urwid.supports_unicode():
386
self.divider = u"─" # \u2500
387
#self.divider = u"━" # \u2501
389
#self.divider = u"-" # \u002d
390
self.divider = u"_" # \u005f
392
254
self.screen.start()
394
256
self.size = self.screen.get_cols_rows()
396
258
self.clients = urwid.SimpleListWalker([])
397
259
self.clients_dict = {}
399
# We will add Text widgets to this list
401
self.max_log_length = max_log_length
403
# We keep a reference to the log widget so we can remove it
404
# from the ListWalker without it getting destroyed
405
self.logbox = ConstrainedListBox(self.log)
407
# This keeps track of whether self.uilist currently has
408
# self.logbox in it or not
409
self.log_visible = True
410
self.log_wrap = u"any"
413
self.log_message_raw((u"bold",
414
u"Mandos Monitor version " + version))
415
self.log_message_raw((u"bold",
260
self.topwidget = urwid.LineBox(urwid.ListBox(self.clients))
261
#self.topwidget = urwid.ListBox(clients)
418
263
self.busname = domain + '.Mandos'
419
264
self.main_loop = gobject.MainLoop()
430
275
mandos_clients = dbus.Dictionary()
432
277
(self.mandos_serv
433
.connect_to_signal(u"ClientRemoved",
278
.connect_to_signal("ClientRemoved",
434
279
self.find_and_remove_client,
435
280
dbus_interface=server_interface,
436
281
byte_arrays=True))
437
282
(self.mandos_serv
438
.connect_to_signal(u"ClientAdded",
283
.connect_to_signal("ClientAdded",
439
284
self.add_new_client,
440
285
dbus_interface=server_interface,
441
286
byte_arrays=True))
443
.connect_to_signal(u"ClientNotFound",
444
self.client_not_found,
445
dbus_interface=server_interface,
447
for path, client in mandos_clients.iteritems():
287
for path, client in (mandos_clients.iteritems()):
448
288
client_proxy_object = self.bus.get_object(self.busname,
450
290
self.add_client(MandosClientWidget(server_proxy_object
298
=self.remove_client),
463
def client_not_found(self, fingerprint, address):
464
self.log_message((u"Client with address %s and fingerprint %s"
465
u" could not be found" % (address,
469
"""This rebuilds the User Interface.
470
Call this when the widget layout needs to change"""
472
#self.uilist.append(urwid.ListBox(self.clients))
473
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
475
#header=urwid.Divider(),
478
urwid.Divider(div_char=
481
self.uilist.append(self.logbox)
483
self.topwidget = urwid.Pile(self.uilist)
485
def log_message(self, message):
486
timestamp = datetime.datetime.now().isoformat()
487
self.log_message_raw(timestamp + u": " + message)
489
def log_message_raw(self, markup):
490
"""Add a log message to the log buffer."""
491
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
492
if (self.max_log_length
493
and len(self.log) > self.max_log_length):
494
del self.log[0:len(self.log)-self.max_log_length-1]
495
self.logbox.set_focus(len(self.logbox.body.contents),
496
coming_from=u"above")
499
def toggle_log_display(self):
500
"""Toggle visibility of the log buffer."""
501
self.log_visible = not self.log_visible
503
#self.log_message(u"Log visibility changed to: "
504
# + unicode(self.log_visible))
506
def change_log_display(self):
507
"""Change type of log display.
508
Currently, this toggles wrapping of text lines."""
509
if self.log_wrap == u"clip":
510
self.log_wrap = u"any"
512
self.log_wrap = u"clip"
513
for textwidget in self.log:
514
textwidget.set_wrap_mode(self.log_wrap)
515
#self.log_message(u"Wrap mode: " + self.log_wrap)
517
301
def find_and_remove_client(self, path, name):
518
302
"""Find an client from its object path and remove it.
583
361
def process_input(self, source, condition):
584
362
keys = self.screen.get_input()
585
translations = { u"ctrl n": u"down", # Emacs
586
u"ctrl p": u"up", # Emacs
587
u"ctrl v": u"page down", # Emacs
588
u"meta v": u"page up", # Emacs
589
u" ": u"page down", # less
590
u"f": u"page down", # less
591
u"b": u"page up", # less
363
translations = { u"j": u"down",
604
375
elif key == u"window resize":
605
376
self.size = self.screen.get_cols_rows()
607
elif key == u"\f": # Ctrl-L
609
elif key == u"l" or key == u"D":
610
self.toggle_log_display()
612
elif key == u"w" or key == u"i":
613
self.change_log_display()
615
elif key == u"?" or key == u"f1" or key == u"esc":
616
if not self.log_visible:
617
self.log_visible = True
619
self.log_message_raw((u"bold",
623
u"l: Log window toggle",
624
u"TAB: Switch window",
626
self.log_message_raw((u"bold",
632
u"s: Start new checker",
639
if self.topwidget.get_focus() is self.logbox:
640
self.topwidget.set_focus(0)
642
self.topwidget.set_focus(self.logbox)
644
#elif (key == u"end" or key == u"meta >" or key == u"G"
646
# pass # xxx end-of-buffer
647
#elif (key == u"home" or key == u"meta <" or key == u"g"
649
# pass # xxx beginning-of-buffer
650
#elif key == u"ctrl e" or key == u"$":
651
# pass # xxx move-end-of-line
652
#elif key == u"ctrl a" or key == u"^":
653
# pass # xxx move-beginning-of-line
654
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
656
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
659
# pass # scroll up log
661
# pass # scroll down log
662
380
elif self.topwidget.selectable():
663
381
self.topwidget.keypress(self.size, key)