30
40
urwid.curses_display.curses.A_UNDERLINE |= (
31
41
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
33
59
class MandosClientPropertyCache(object):
34
60
"""This wraps a Mandos Client D-Bus proxy object, caches the
35
61
properties and calls a hook function when any of them are
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,
64
def __init__(self, proxy_object=None, *args, **kwargs):
59
65
self.proxy = proxy_object # Mandos Client proxy object
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",
67
self.properties = dict()
68
self.proxy.connect_to_signal(u"PropertyChanged",
68
69
self.property_changed,
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)
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__(
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)
98
81
def property_changed(self, property=None, value=None):
99
82
"""This is called whenever we get a PropertyChanged signal
100
83
It updates the changed property in the "properties" dict.
102
# Convert name and value
103
property_name, cvalue = self.convert_property(property, value)
104
85
# Update properties dict with new value
105
self.properties[property_name] = cvalue
86
self.properties[property] = value
108
89
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
112
93
def __init__(self, server_proxy_object=None, update_hook=None,
113
delete_hook=None, *args, **kwargs):
94
delete_hook=None, logger=None, *args, **kwargs):
114
95
# Called on update
115
96
self.update_hook = update_hook
116
97
# Called on delete
117
98
self.delete_hook = delete_hook
118
99
# Mandos Server proxy object
119
100
self.server_proxy_object = server_proxy_object
104
self._update_timer_callback_tag = None
105
self.last_checker_failed = False
121
107
# The widget shown normally
122
self._text_widget = urwid.Text("")
108
self._text_widget = urwid.Text(u"")
123
109
# The widget shown when we have focus
124
self._focus_text_widget = urwid.Text("")
110
self._focus_text_widget = urwid.Text(u"")
125
111
super(MandosClientWidget, self).__init__(
126
112
update_hook=update_hook, delete_hook=delete_hook,
129
115
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))
131
210
def selectable(self):
132
211
"""Make this a "selectable" widget.
154
233
u"bold-underline-blink":
155
234
u"bold-underline-blink-standout",
158
237
# Rebuild focus and non-focus widgets using current properties
159
self._text = (u'name="%(name)s", enabled=%(enabled)s'
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)
161
265
if not urwid.supports_unicode():
162
266
self._text = self._text.encode("ascii", "replace")
163
textlist = [(u"normal", u"BLÄRGH: "), (u"bold", self._text)]
267
textlist = [(u"normal", self._text)]
164
268
self._text_widget.set_text(textlist)
165
269
self._focus_text_widget.set_text([(with_standout[text[0]],
187
299
def keypress(self, (maxcol,), key):
189
301
This overrides the method from urwid.FlowWidget"""
190
if key == u"e" or key == u"+":
192
elif key == u"d" or key == u"-":
194
elif key == u"r" or key == u"_":
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":
195
313
self.server_proxy_object.RemoveClient(self.proxy
197
315
elif key == u"s":
198
self.proxy.StartChecker()
200
self.proxy.StopChecker()
316
self.proxy.StartChecker(dbus_interface = client_interface)
201
317
elif key == u"S":
202
self.proxy.CheckedOK()
318
self.proxy.StopChecker(dbus_interface = client_interface)
320
self.proxy.CheckedOK(dbus_interface = client_interface)
204
322
# elif key == u"p" or key == "=":
205
323
# self.proxy.pause()
347
class ConstrainedListBox(urwid.ListBox):
348
"""Like a normal urwid.ListBox, but will consume all "up" or
349
"down" key presses, thus not allowing any containing widgets to
350
use them as an excuse to shift focus away from this widget.
352
def keypress(self, (maxcol, maxrow), key):
353
ret = super(ConstrainedListBox, self).keypress((maxcol,
355
if ret in (u"up", u"down"):
225
360
class UserInterface(object):
226
361
"""This is the entire user interface - the whole screen
227
362
with boxes, lists of client widgets, etc.
230
DBusGMainLoop(set_as_default=True )
364
def __init__(self, max_log_length=1000):
365
DBusGMainLoop(set_as_default=True)
232
367
self.screen = urwid.curses_display.Screen()
389
if urwid.supports_unicode():
390
self.divider = u"─" # \u2500
391
#self.divider = u"━" # \u2501
393
#self.divider = u"-" # \u002d
394
self.divider = u"_" # \u005f
254
396
self.screen.start()
256
398
self.size = self.screen.get_cols_rows()
258
400
self.clients = urwid.SimpleListWalker([])
259
401
self.clients_dict = {}
260
self.topwidget = urwid.LineBox(urwid.ListBox(self.clients))
261
#self.topwidget = urwid.ListBox(clients)
403
# We will add Text widgets to this list
405
self.max_log_length = max_log_length
407
# We keep a reference to the log widget so we can remove it
408
# from the ListWalker without it getting destroyed
409
self.logbox = ConstrainedListBox(self.log)
411
# This keeps track of whether self.uilist currently has
412
# self.logbox in it or not
413
self.log_visible = True
414
self.log_wrap = u"any"
417
self.log_message_raw((u"bold",
418
u"Mandos Monitor version " + version))
419
self.log_message_raw((u"bold",
263
422
self.busname = domain + '.Mandos'
264
423
self.main_loop = gobject.MainLoop()
275
434
mandos_clients = dbus.Dictionary()
277
436
(self.mandos_serv
278
.connect_to_signal("ClientRemoved",
437
.connect_to_signal(u"ClientRemoved",
279
438
self.find_and_remove_client,
280
439
dbus_interface=server_interface,
281
440
byte_arrays=True))
282
441
(self.mandos_serv
283
.connect_to_signal("ClientAdded",
442
.connect_to_signal(u"ClientAdded",
284
443
self.add_new_client,
285
444
dbus_interface=server_interface,
286
445
byte_arrays=True))
287
for path, client in (mandos_clients.iteritems()):
447
.connect_to_signal(u"ClientNotFound",
448
self.client_not_found,
449
dbus_interface=server_interface,
451
for path, client in mandos_clients.iteritems():
288
452
client_proxy_object = self.bus.get_object(self.busname,
290
454
self.add_client(MandosClientWidget(server_proxy_object
298
=self.remove_client),
467
def client_not_found(self, fingerprint, address):
468
self.log_message((u"Client with address %s and fingerprint %s"
469
u" could not be found" % (address,
473
"""This rebuilds the User Interface.
474
Call this when the widget layout needs to change"""
476
#self.uilist.append(urwid.ListBox(self.clients))
477
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
479
#header=urwid.Divider(),
482
urwid.Divider(div_char=
485
self.uilist.append(self.logbox)
487
self.topwidget = urwid.Pile(self.uilist)
489
def log_message(self, message):
490
timestamp = datetime.datetime.now().isoformat()
491
self.log_message_raw(timestamp + u": " + message)
493
def log_message_raw(self, markup):
494
"""Add a log message to the log buffer."""
495
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
496
if (self.max_log_length
497
and len(self.log) > self.max_log_length):
498
del self.log[0:len(self.log)-self.max_log_length-1]
499
self.logbox.set_focus(len(self.logbox.body.contents),
500
coming_from=u"above")
503
def toggle_log_display(self):
504
"""Toggle visibility of the log buffer."""
505
self.log_visible = not self.log_visible
507
self.log_message(u"Log visibility changed to: "
508
+ unicode(self.log_visible))
510
def change_log_display(self):
511
"""Change type of log display.
512
Currently, this toggles wrapping of text lines."""
513
if self.log_wrap == u"clip":
514
self.log_wrap = u"any"
516
self.log_wrap = u"clip"
517
for textwidget in self.log:
518
textwidget.set_wrap_mode(self.log_wrap)
519
self.log_message(u"Wrap mode: " + self.log_wrap)
301
521
def find_and_remove_client(self, path, name):
302
522
"""Find an client from its object path and remove it.
361
587
def process_input(self, source, condition):
362
588
keys = self.screen.get_input()
363
translations = { u"j": u"down",
589
translations = { u"ctrl n": u"down", # Emacs
590
u"ctrl p": u"up", # Emacs
591
u"ctrl v": u"page down", # Emacs
592
u"meta v": u"page up", # Emacs
593
u" ": u"page down", # less
594
u"f": u"page down", # less
595
u"b": u"page up", # less
375
608
elif key == u"window resize":
376
609
self.size = self.screen.get_cols_rows()
611
elif key == u"\f": # Ctrl-L
613
elif key == u"l" or key == u"D":
614
self.toggle_log_display()
616
elif key == u"w" or key == u"i":
617
self.change_log_display()
619
elif key == u"?" or key == u"f1" or key == u"esc":
620
if not self.log_visible:
621
self.log_visible = True
623
self.log_message_raw((u"bold",
627
u"l: Log window toggle",
628
u"TAB: Switch window",
630
self.log_message_raw((u"bold",
636
u"s: Start new checker",
643
if self.topwidget.get_focus() is self.logbox:
644
self.topwidget.set_focus(0)
646
self.topwidget.set_focus(self.logbox)
648
#elif (key == u"end" or key == u"meta >" or key == u"G"
650
# pass # xxx end-of-buffer
651
#elif (key == u"home" or key == u"meta <" or key == u"g"
653
# pass # xxx beginning-of-buffer
654
#elif key == u"ctrl e" or key == u"$":
655
# pass # xxx move-end-of-line
656
#elif key == u"ctrl a" or key == u"^":
657
# pass # xxx move-beginning-of-line
658
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
660
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
663
# pass # scroll up log
665
# pass # scroll down log
380
666
elif self.topwidget.selectable():
381
667
self.topwidget.keypress(self.size, key)