To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to mandos-monitor
- browse files at revision 404
- compare with another revision
- download diff
- download tarball
- view history from revision 404
- Committer: Teddy Hogeborn
- Date: 2009-11-05 19:16:46 UTC
- Revision ID: teddy@fukt.bsnet.se-20091105191646-5l7bkq5h4wkh3huh
* mandos-monitor: New prototype version of interactive server
administraton tool using D-Bus.
administraton tool using D-Bus.
added
removed
mandos-monitor
4
4
from __future__ import division, absolute_import, with_statement
5
5
6
6
import sys
7
import os
8
7
import signal
9
8
10
import datetime
11
12
9
import urwid.curses_display
13
10
import urwid
14
11
19
16
20
17
import UserList
21
18
22
import locale
23
24
locale.setlocale(locale.LC_ALL, u'')
25
26
import logging
27
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
28
29
19
# Some useful constants
30
20
domain = 'se.bsnet.fukt'
31
21
server_interface = domain + '.Mandos'
32
22
client_interface = domain + '.Mandos.Client'
33
version = "1.0.15"
23
version = "1.0.14"
34
24
35
25
# Always run in monochrome mode
36
26
urwid.curses_display.curses.has_colors = lambda : False
40
30
urwid.curses_display.curses.A_UNDERLINE |= (
41
31
urwid.curses_display.curses.A_BLINK)
42
32
43
def isoformat_to_datetime(iso):
44
"Parse an ISO 8601 date string to a datetime.datetime()"
45
if not iso:
46
return None
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),
52
int(month),
53
int(day),
54
int(hour),
55
int(minute),
56
int(second), # Whole seconds
57
int(fraction*1000000)) # Microseconds
58
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
62
36
changed.
63
37
"""
64
def __init__(self, proxy_object=None, *args, **kwargs):
38
def __init__(self, proxy_object=None, properties=None, *args,
39
**kwargs):
40
# Type conversion mapping
41
self.type_map = {
42
dbus.ObjectPath: unicode,
43
dbus.ByteArray: str,
44
dbus.Signature: unicode,
45
dbus.Byte: chr,
46
dbus.Int16: int,
47
dbus.UInt16: int,
48
dbus.Int32: int,
49
dbus.UInt32: int,
50
dbus.Int64: int,
51
dbus.UInt64: int,
52
dbus.Dictionary: dict,
53
dbus.Array: list,
54
dbus.String: unicode,
55
dbus.Boolean: bool,
56
dbus.Double: float,
57
dbus.Struct: tuple,
58
}
65
59
self.proxy = proxy_object # Mandos Client proxy object
66
60
67
self.properties = dict()
68
self.proxy.connect_to_signal(u"PropertyChanged",
61
if properties is None:
62
self.properties = dict()
63
else:
64
self.properties = dict(self.convert_property(prop, val)
65
for prop, val in
66
properties.iteritems())
67
self.proxy.connect_to_signal("PropertyChanged",
69
68
self.property_changed,
70
69
client_interface,
71
70
byte_arrays=True)
72
71
73
self.properties.update(
74
self.proxy.GetAll(client_interface,
75
dbus_interface = dbus.PROPERTIES_IFACE))
76
77
#XXX This break good super behaviour!
78
# super(MandosClientPropertyCache, self).__init__(
79
# *args, **kwargs)
72
if properties is None:
73
self.properties.update(
74
self.convert_property(prop, val)
75
for prop, val in
76
self.proxy.GetAll(client_interface,
77
dbus_interface =
78
dbus.PROPERTIES_IFACE).iteritems())
79
super(MandosClientPropertyCache, self).__init__(
80
proxy_object=proxy_object,
81
properties=properties, *args, **kwargs)
80
82
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".
87
"""
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"))
92
try:
93
convfunc = self.type_map[type(value)]
94
except KeyError:
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.
84
101
"""
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
87
106
88
107
89
108
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
91
110
"""
92
111
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
101
# Logger
102
self.logger = logger
103
104
self._update_timer_callback_tag = None
105
self.last_checker_failed = False
106
120
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,
113
127
*args, **kwargs)
114
128
self.update()
115
129
self.opened = False
116
self.proxy.connect_to_signal(u"CheckerCompleted",
117
self.checker_completed,
118
client_interface,
119
byte_arrays=True)
120
self.proxy.connect_to_signal(u"CheckerStarted",
121
self.checker_started,
122
client_interface,
123
byte_arrays=True)
124
self.proxy.connect_to_signal(u"GotSecret",
125
self.got_secret,
126
client_interface,
127
byte_arrays=True)
128
self.proxy.connect_to_signal(u"NeedApproval",
129
self.need_approval,
130
client_interface,
131
byte_arrays=True)
132
self.proxy.connect_to_signal(u"Rejected",
133
self.rejected,
134
client_interface,
135
byte_arrays=True)
136
last_checked_ok = isoformat_to_datetime(self.properties
137
[u"LastCheckedOK"])
138
if last_checked_ok is None:
139
self.last_checker_failed = True
140
else:
141
self.last_checker_failed = ((datetime.datetime.utcnow()
142
- last_checked_ok)
143
> datetime.timedelta
144
(milliseconds=
145
self.properties
146
[u"Interval"]))
147
if self.last_checker_failed:
148
self._update_timer_callback_tag = (gobject.timeout_add
149
(1000,
150
self.update_timer))
151
152
def checker_completed(self, exitstatus, condition, command):
153
if exitstatus == 0:
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")'
159
u' was successful'
160
% (self.properties[u"Name"], command))
161
self.update()
162
return
163
# Checker failed
164
if not self.last_checker_failed:
165
self.last_checker_failed = True
166
self._update_timer_callback_tag = (gobject.timeout_add
167
(1000,
168
self.update_timer))
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")'
181
u' dumped core'
182
% (self.properties[u"Name"], command))
183
else:
184
self.logger(u'Checker for client %s completed'
185
u' mysteriously')
186
self.update()
187
188
def checker_started(self, command):
189
#self.logger(u'Client %s started checker "%s"'
190
# % (self.properties[u"Name"], unicode(command)))
191
pass
192
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"])
197
198
def need_approval(self, timeout, default):
199
if not default:
200
message = u'Client %s needs approval within %s seconds'
201
else:
202
message = u'Client %s will get its secret in %s seconds'
203
self.logger(message
204
% (self.properties[u"Name"], timeout/1000))
205
206
def rejected(self, reason):
207
self.logger(u'Client %s was rejected; reason: %s'
208
% (self.properties[u"Name"], reason))
209
130
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",
235
156
}
236
157
237
158
# Rebuild focus and non-focus widgets using current properties
238
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?"
247
else:
248
message = u"Seeks approval to send secret. (a)pprove?"
249
elif self.last_checker_failed:
250
timeout = datetime.timedelta(milliseconds
251
= self.properties
252
[u"Timeout"])
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'
259
u' gets diabled: %s'
260
% unicode(timer).rsplit(".", 1)[0])
261
else:
262
message = u"enabled"
263
self._text = "%s%s" % (base, message)
264
159
self._text = (u'name="%(name)s", enabled=%(enabled)s'
160
% self.properties)
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]],
270
166
text[1])
278
174
if self.update_hook is not None:
279
175
self.update_hook()
280
176
281
def update_timer(self):
282
"called by gobject"
283
self.update()
284
return True # Keep calling this
285
286
177
def delete(self):
287
if self._update_timer_callback_tag is not None:
288
gobject.source_remove(self._update_timer_callback_tag)
289
self._update_timer_callback_tag = None
290
178
if self.delete_hook is not None:
291
179
self.delete_hook(self)
292
180
299
187
def keypress(self, (maxcol,), key):
300
188
"""Handle keys.
301
189
This overrides the method from urwid.FlowWidget"""
302
if key == u"+":
303
self.proxy.Enable(dbus_interface = client_interface)
304
elif key == u"-":
305
self.proxy.Disable(dbus_interface = client_interface)
306
elif key == u"a":
307
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
308
dbus_interface = client_interface)
309
elif key == u"d":
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"+":
191
self.proxy.Enable()
192
elif key == u"d" or key == u"-":
193
self.proxy.Disable()
194
elif key == u"r" or key == u"_":
313
195
self.server_proxy_object.RemoveClient(self.proxy
314
196
.object_path)
315
197
elif key == u"s":
316
self.proxy.StartChecker(dbus_interface = client_interface)
198
self.proxy.StartChecker()
199
elif key == u"c":
200
self.proxy.StopChecker()
317
201
elif key == u"S":
318
self.proxy.StopChecker(dbus_interface = client_interface)
319
elif key == u"C":
320
self.proxy.CheckedOK(dbus_interface = client_interface)
202
self.proxy.CheckedOK()
321
203
# xxx
322
204
# elif key == u"p" or key == "=":
323
205
# self.proxy.pause()
325
207
# self.proxy.unpause()
326
208
# elif key == u"RET":
327
209
# self.open()
328
# elif key == u"+":
329
# self.proxy.Approve(True)
330
# elif key == u"-":
331
# self.proxy.Approve(False)
332
210
else:
333
211
return key
334
212
344
222
self.update()
345
223
346
224
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.
351
"""
352
def keypress(self, (maxcol, maxrow), key):
353
ret = super(ConstrainedListBox, self).keypress((maxcol,
354
maxrow), key)
355
if ret in (u"up", u"down"):
356
return
357
return ret
358
359
360
225
class UserInterface(object):
361
226
"""This is the entire user interface - the whole screen
362
227
with boxes, lists of client widgets, etc.
363
228
"""
364
def __init__(self, max_log_length=1000):
365
DBusGMainLoop(set_as_default=True)
229
def __init__(self):
230
DBusGMainLoop(set_as_default=True )
366
231
367
232
self.screen = urwid.curses_display.Screen()
368
233
386
251
u"standout")),
387
252
))
388
253
389
if urwid.supports_unicode():
390
self.divider = u"─" # \u2500
391
#self.divider = u"━" # \u2501
392
else:
393
#self.divider = u"-" # \u002d
394
self.divider = u"_" # \u005f
395
396
254
self.screen.start()
397
255
398
256
self.size = self.screen.get_cols_rows()
399
257
400
258
self.clients = urwid.SimpleListWalker([])
401
259
self.clients_dict = {}
402
403
# We will add Text widgets to this list
404
self.log = []
405
self.max_log_length = max_log_length
406
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)
410
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"
415
416
self.rebuild()
417
self.log_message_raw((u"bold",
418
u"Mandos Monitor version " + version))
419
self.log_message_raw((u"bold",
420
u"q: Quit ?: Help"))
260
self.topwidget = urwid.LineBox(urwid.ListBox(self.clients))
261
#self.topwidget = urwid.ListBox(clients)
421
262
422
263
self.busname = domain + '.Mandos'
423
264
self.main_loop = gobject.MainLoop()
434
275
mandos_clients = dbus.Dictionary()
435
276
436
277
(self.mandos_serv
437
.connect_to_signal(u"ClientRemoved",
278
.connect_to_signal("ClientRemoved",
438
279
self.find_and_remove_client,
439
280
dbus_interface=server_interface,
440
281
byte_arrays=True))
441
282
(self.mandos_serv
442
.connect_to_signal(u"ClientAdded",
283
.connect_to_signal("ClientAdded",
443
284
self.add_new_client,
444
285
dbus_interface=server_interface,
445
286
byte_arrays=True))
446
(self.mandos_serv
447
.connect_to_signal(u"ClientNotFound",
448
self.client_not_found,
449
dbus_interface=server_interface,
450
byte_arrays=True))
451
for path, client in mandos_clients.iteritems():
287
for path, client in (mandos_clients.iteritems()):
452
288
client_proxy_object = self.bus.get_object(self.busname,
453
289
path)
454
290
self.add_client(MandosClientWidget(server_proxy_object
459
295
update_hook
460
296
=self.refresh,
461
297
delete_hook
462
=self.remove_client,
463
logger
464
=self.log_message),
298
=self.remove_client),
465
299
path=path)
466
300
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,
470
fingerprint)))
471
472
def rebuild(self):
473
"""This rebuilds the User Interface.
474
Call this when the widget layout needs to change"""
475
self.uilist = []
476
#self.uilist.append(urwid.ListBox(self.clients))
477
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
478
clients),
479
#header=urwid.Divider(),
480
header=None,
481
footer=
482
urwid.Divider(div_char=
483
self.divider)))
484
if self.log_visible:
485
self.uilist.append(self.logbox)
486
pass
487
self.topwidget = urwid.Pile(self.uilist)
488
489
def log_message(self, message):
490
timestamp = datetime.datetime.now().isoformat()
491
self.log_message_raw(timestamp + u": " + message)
492
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")
501
self.refresh()
502
503
def toggle_log_display(self):
504
"""Toggle visibility of the log buffer."""
505
self.log_visible = not self.log_visible
506
self.rebuild()
507
self.log_message(u"Log visibility changed to: "
508
+ unicode(self.log_visible))
509
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"
515
else:
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)
520
521
301
def find_and_remove_client(self, path, name):
522
302
"""Find an client from its object path and remove it.
523
303
530
310
return
531
311
self.remove_client(client, path)
532
312
533
def add_new_client(self, path):
313
def add_new_client(self, path, properties):
534
314
client_proxy_object = self.bus.get_object(self.busname, path)
535
315
self.add_client(MandosClientWidget(server_proxy_object
536
316
=self.mandos_serv,
537
317
proxy_object
538
318
=client_proxy_object,
319
properties=properties,
539
320
update_hook
540
321
=self.refresh,
541
322
delete_hook
542
=self.remove_client,
543
logger
544
=self.log_message),
323
=self.remove_client),
545
324
path=path)
546
325
547
326
def add_client(self, client, path=None):
549
328
if path is None:
550
329
path = client.proxy.object_path
551
330
self.clients_dict[path] = client
552
self.clients.sort(None, lambda c: c.properties[u"Name"])
331
self.clients.sort(None, lambda c: c.properties[u"name"])
553
332
self.refresh()
554
333
555
334
def remove_client(self, client, path=None):
557
336
if path is None:
558
337
path = client.proxy.object_path
559
338
del self.clients_dict[path]
560
if not self.clients_dict:
561
# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
562
# is completely emptied, we need to recreate it.
563
self.clients = urwid.SimpleListWalker([])
564
self.rebuild()
565
339
self.refresh()
566
340
567
341
def refresh(self):
586
360
587
361
def process_input(self, source, condition):
588
362
keys = self.screen.get_input()
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
596
u"j": u"down", # vi
597
u"k": u"up", # vi
363
translations = { u"j": u"down",
364
u"k": u"up",
598
365
}
599
366
for key in keys:
600
367
try:
608
375
elif key == u"window resize":
609
376
self.size = self.screen.get_cols_rows()
610
377
self.refresh()
611
elif key == u"\f": # Ctrl-L
612
self.refresh()
613
elif key == u"l" or key == u"D":
614
self.toggle_log_display()
615
self.refresh()
616
elif key == u"w" or key == u"i":
617
self.change_log_display()
618
self.refresh()
619
elif key == u"?" or key == u"f1" or key == u"esc":
620
if not self.log_visible:
621
self.log_visible = True
622
self.rebuild()
623
self.log_message_raw((u"bold",
624
u" ".
625
join((u"q: Quit",
626
u"?: Help",
627
u"l: Log window toggle",
628
u"TAB: Switch window",
629
u"w: Wrap (log)"))))
630
self.log_message_raw((u"bold",
631
u" "
632
.join((u"Clients:",
633
u"+: Enable",
634
u"-: Disable",
635
u"r: Remove",
636
u"s: Start new checker",
637
u"S: Stop checker",
638
u"C: Checker OK",
639
u"a: Approve",
640
u"d: Deny"))))
641
self.refresh()
642
elif key == u"tab":
643
if self.topwidget.get_focus() is self.logbox:
644
self.topwidget.set_focus(0)
645
else:
646
self.topwidget.set_focus(self.logbox)
647
self.refresh()
648
#elif (key == u"end" or key == u"meta >" or key == u"G"
649
# or key == u">"):
650
# pass # xxx end-of-buffer
651
#elif (key == u"home" or key == u"meta <" or key == u"g"
652
# or key == u"<"):
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":
659
# pass # xxx left
660
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
661
# pass # xxx right
662
#elif key == u"a":
663
# pass # scroll up log
664
#elif key == u"z":
665
# pass # scroll down log
378
elif key == " ":
379
self.refresh()
666
380
elif self.topwidget.selectable():
667
381
self.topwidget.keypress(self.size, key)
668
382
self.refresh()
671
385
ui = UserInterface()
672
386
try:
673
387
ui.run()
674
except KeyboardInterrupt:
675
ui.screen.stop()
676
except Exception, e:
677
ui.log_message(unicode(e))
388
except:
678
389
ui.screen.stop()
679
390
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0