To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to mandos-monitor
- browse files at revision 237.3.1
- compare with another revision
- download diff
- download tarball
- view history from revision 237.3.1
- Committer: Mooie
- Date: 2009-01-10 00:53:09 UTC
- mto: (237.2.21 mandos)
- mto: This revision was merged to the branch mainline in revision 244.
- Revision ID: mooie@thinkmoo-20090110005309-1f1uhhvrif4tg6ev
Updated Makefile to use -fPIC.
Updated Makefile to use -pie and -fPIE correctly.
Updated Makefile to use -pie and -fPIE correctly.
- files removed:
- DBUS-API
- files renamed:
- mandos-ctl => mandos-list
- files modified:
- INSTALL
added
removed
mandos-monitor
1
#!/usr/bin/python
2
# -*- mode: python; coding: utf-8 -*-
3
4
from __future__ import division, absolute_import, with_statement
5
6
import sys
7
import os
8
import signal
9
10
import datetime
11
12
import urwid.curses_display
13
import urwid
14
15
from dbus.mainloop.glib import DBusGMainLoop
16
import gobject
17
18
import dbus
19
20
import UserList
21
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
# Some useful constants
30
domain = 'se.bsnet.fukt'
31
server_interface = domain + '.Mandos'
32
client_interface = domain + '.Mandos.Client'
33
version = "1.0.15"
34
35
# Always run in monochrome mode
36
urwid.curses_display.curses.has_colors = lambda : False
37
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)
42
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
class MandosClientPropertyCache(object):
60
"""This wraps a Mandos Client D-Bus proxy object, caches the
61
properties and calls a hook function when any of them are
62
changed.
63
"""
64
def __init__(self, proxy_object=None, *args, **kwargs):
65
self.proxy = proxy_object # Mandos Client proxy object
66
67
self.properties = dict()
68
self.proxy.connect_to_signal(u"PropertyChanged",
69
self.property_changed,
70
client_interface,
71
byte_arrays=True)
72
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)
80
81
def property_changed(self, property=None, value=None):
82
"""This is called whenever we get a PropertyChanged signal
83
It updates the changed property in the "properties" dict.
84
"""
85
# Update properties dict with new value
86
self.properties[property] = value
87
88
89
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
90
"""A Mandos Client which is visible on the screen.
91
"""
92
93
def __init__(self, server_proxy_object=None, update_hook=None,
94
delete_hook=None, logger=None, *args, **kwargs):
95
# Called on update
96
self.update_hook = update_hook
97
# Called on delete
98
self.delete_hook = delete_hook
99
# Mandos Server proxy object
100
self.server_proxy_object = server_proxy_object
101
# Logger
102
self.logger = logger
103
104
self._update_timer_callback_tag = None
105
self._update_timer_callback_lock = 0
106
self.last_checker_failed = False
107
108
# The widget shown normally
109
self._text_widget = urwid.Text(u"")
110
# The widget shown when we have focus
111
self._focus_text_widget = urwid.Text(u"")
112
super(MandosClientWidget, self).__init__(
113
update_hook=update_hook, delete_hook=delete_hook,
114
*args, **kwargs)
115
self.update()
116
self.opened = False
117
118
last_checked_ok = isoformat_to_datetime(self.properties
119
[u"LastCheckedOK"])
120
if last_checked_ok is None:
121
self.last_checker_failed = True
122
else:
123
self.last_checker_failed = ((datetime.datetime.utcnow()
124
- last_checked_ok)
125
> datetime.timedelta
126
(milliseconds=
127
self.properties
128
[u"Interval"]))
129
130
if self.last_checker_failed:
131
self.using_timer(True)
132
133
if self.need_approval:
134
self.using_timer(True)
135
136
self.proxy.connect_to_signal(u"CheckerCompleted",
137
self.checker_completed,
138
client_interface,
139
byte_arrays=True)
140
self.proxy.connect_to_signal(u"CheckerStarted",
141
self.checker_started,
142
client_interface,
143
byte_arrays=True)
144
self.proxy.connect_to_signal(u"GotSecret",
145
self.got_secret,
146
client_interface,
147
byte_arrays=True)
148
self.proxy.connect_to_signal(u"NeedApproval",
149
self.need_approval,
150
client_interface,
151
byte_arrays=True)
152
self.proxy.connect_to_signal(u"Rejected",
153
self.rejected,
154
client_interface,
155
byte_arrays=True)
156
157
def property_changed(self, property=None, value=None):
158
super(self, MandosClientWidget).property_changed(property,
159
value)
160
if property == u"ApprovalPending":
161
using_timer(bool(value))
162
163
def using_timer(self, flag):
164
"""Call this method with True or False when timer should be
165
activated or deactivated.
166
"""
167
old = self._update_timer_callback_lock
168
if flag:
169
self._update_timer_callback_lock += 1
170
else:
171
self._update_timer_callback_lock -= 1
172
if old == 0 and self._update_timer_callback_lock:
173
self._update_timer_callback_tag = (gobject.timeout_add
174
(1000,
175
self.update_timer))
176
elif old and self._update_timer_callback_lock == 0:
177
gobject.source_remove(self._update_timer_callback_tag)
178
self._update_timer_callback_tag = None
179
180
def checker_completed(self, exitstatus, condition, command):
181
if exitstatus == 0:
182
if self.last_checker_failed:
183
self.last_checker_failed = False
184
self.using_timer(False)
185
#self.logger(u'Checker for client %s (command "%s")'
186
# u' was successful'
187
# % (self.properties[u"Name"], command))
188
self.update()
189
return
190
# Checker failed
191
if not self.last_checker_failed:
192
self.last_checker_failed = True
193
self.using_timer(True)
194
if os.WIFEXITED(condition):
195
self.logger(u'Checker for client %s (command "%s")'
196
u' failed with exit code %s'
197
% (self.properties[u"Name"], command,
198
os.WEXITSTATUS(condition)))
199
elif os.WIFSIGNALED(condition):
200
self.logger(u'Checker for client %s (command "%s")'
201
u' was killed by signal %s'
202
% (self.properties[u"Name"], command,
203
os.WTERMSIG(condition)))
204
elif os.WCOREDUMP(condition):
205
self.logger(u'Checker for client %s (command "%s")'
206
u' dumped core'
207
% (self.properties[u"Name"], command))
208
else:
209
self.logger(u'Checker for client %s completed'
210
u' mysteriously')
211
self.update()
212
213
def checker_started(self, command):
214
#self.logger(u'Client %s started checker "%s"'
215
# % (self.properties[u"Name"], unicode(command)))
216
pass
217
218
def got_secret(self):
219
self.last_checker_failed = False
220
self.logger(u'Client %s received its secret'
221
% self.properties[u"Name"])
222
223
def need_approval(self, timeout, default):
224
if not default:
225
message = u'Client %s needs approval within %s seconds'
226
else:
227
message = u'Client %s will get its secret in %s seconds'
228
self.logger(message
229
% (self.properties[u"Name"], timeout/1000))
230
self.using_timer(True)
231
232
def rejected(self, reason):
233
self.logger(u'Client %s was rejected; reason: %s'
234
% (self.properties[u"Name"], reason))
235
236
def selectable(self):
237
"""Make this a "selectable" widget.
238
This overrides the method from urwid.FlowWidget."""
239
return True
240
241
def rows(self, (maxcol,), focus=False):
242
"""How many rows this widget will occupy might depend on
243
whether we have focus or not.
244
This overrides the method from urwid.FlowWidget"""
245
return self.current_widget(focus).rows((maxcol,), focus=focus)
246
247
def current_widget(self, focus=False):
248
if focus or self.opened:
249
return self._focus_widget
250
return self._widget
251
252
def update(self):
253
"Called when what is visible on the screen should be updated."
254
# How to add standout mode to a style
255
with_standout = { u"normal": u"standout",
256
u"bold": u"bold-standout",
257
u"underline-blink":
258
u"underline-blink-standout",
259
u"bold-underline-blink":
260
u"bold-underline-blink-standout",
261
}
262
263
# Rebuild focus and non-focus widgets using current properties
264
265
# Base part of a client. Name!
266
base = (u'%(name)s: '
267
% {u"name": self.properties[u"Name"]})
268
if not self.properties[u"Enabled"]:
269
message = u"DISABLED"
270
elif self.properties[u"ApprovalPending"]:
271
timeout = datetime.timedelta(milliseconds
272
= self.properties
273
[u"ApprovalDelay"])
274
last_approval_request = isoformat_to_datetime(
275
self.properties[u"LastApprovalRequest"])
276
if last_approval_request is not None:
277
timer = timeout - (datetime.datetime.utcnow()
278
- last_approval_request)
279
else:
280
timer = datetime.timedelta()
281
if self.properties[u"ApprovedByDefault"]:
282
message = u"Approval in %s. (d)eny?"
283
else:
284
message = u"Denial in %s. (a)pprove?"
285
message = message % unicode(timer).rsplit(".", 1)[0]
286
elif self.last_checker_failed:
287
timeout = datetime.timedelta(milliseconds
288
= self.properties
289
[u"Timeout"])
290
last_ok = isoformat_to_datetime(
291
max((self.properties[u"LastCheckedOK"]
292
or self.properties[u"Created"]),
293
self.properties[u"LastEnabled"]))
294
timer = timeout - (datetime.datetime.utcnow() - last_ok)
295
message = (u'A checker has failed! Time until client'
296
u' gets disabled: %s'
297
% unicode(timer).rsplit(".", 1)[0])
298
else:
299
message = u"enabled"
300
self._text = "%s%s" % (base, message)
301
302
if not urwid.supports_unicode():
303
self._text = self._text.encode("ascii", "replace")
304
textlist = [(u"normal", self._text)]
305
self._text_widget.set_text(textlist)
306
self._focus_text_widget.set_text([(with_standout[text[0]],
307
text[1])
308
if isinstance(text, tuple)
309
else text
310
for text in textlist])
311
self._widget = self._text_widget
312
self._focus_widget = urwid.AttrWrap(self._focus_text_widget,
313
"standout")
314
# Run update hook, if any
315
if self.update_hook is not None:
316
self.update_hook()
317
318
def update_timer(self):
319
"called by gobject"
320
self.update()
321
return True # Keep calling this
322
323
def delete(self):
324
if self._update_timer_callback_tag is not None:
325
gobject.source_remove(self._update_timer_callback_tag)
326
self._update_timer_callback_tag = None
327
if self.delete_hook is not None:
328
self.delete_hook(self)
329
330
def render(self, (maxcol,), focus=False):
331
"""Render differently if we have focus.
332
This overrides the method from urwid.FlowWidget"""
333
return self.current_widget(focus).render((maxcol,),
334
focus=focus)
335
336
def keypress(self, (maxcol,), key):
337
"""Handle keys.
338
This overrides the method from urwid.FlowWidget"""
339
if key == u"+":
340
self.proxy.Enable(dbus_interface = client_interface)
341
elif key == u"-":
342
self.proxy.Disable(dbus_interface = client_interface)
343
elif key == u"a":
344
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
345
dbus_interface = client_interface)
346
elif key == u"d":
347
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
348
dbus_interface = client_interface)
349
elif key == u"r" or key == u"_" or key == u"ctrl k":
350
self.server_proxy_object.RemoveClient(self.proxy
351
.object_path)
352
elif key == u"s":
353
self.proxy.StartChecker(dbus_interface = client_interface)
354
elif key == u"S":
355
self.proxy.StopChecker(dbus_interface = client_interface)
356
elif key == u"C":
357
self.proxy.CheckedOK(dbus_interface = client_interface)
358
# xxx
359
# elif key == u"p" or key == "=":
360
# self.proxy.pause()
361
# elif key == u"u" or key == ":":
362
# self.proxy.unpause()
363
# elif key == u"RET":
364
# self.open()
365
else:
366
return key
367
368
def property_changed(self, property=None, value=None,
369
*args, **kwargs):
370
"""Call self.update() if old value is not new value.
371
This overrides the method from MandosClientPropertyCache"""
372
property_name = unicode(property)
373
old_value = self.properties.get(property_name)
374
super(MandosClientWidget, self).property_changed(
375
property=property, value=value, *args, **kwargs)
376
if self.properties.get(property_name) != old_value:
377
self.update()
378
379
380
class ConstrainedListBox(urwid.ListBox):
381
"""Like a normal urwid.ListBox, but will consume all "up" or
382
"down" key presses, thus not allowing any containing widgets to
383
use them as an excuse to shift focus away from this widget.
384
"""
385
def keypress(self, (maxcol, maxrow), key):
386
ret = super(ConstrainedListBox, self).keypress((maxcol,
387
maxrow), key)
388
if ret in (u"up", u"down"):
389
return
390
return ret
391
392
393
class UserInterface(object):
394
"""This is the entire user interface - the whole screen
395
with boxes, lists of client widgets, etc.
396
"""
397
def __init__(self, max_log_length=1000):
398
DBusGMainLoop(set_as_default=True)
399
400
self.screen = urwid.curses_display.Screen()
401
402
self.screen.register_palette((
403
(u"normal",
404
u"default", u"default", None),
405
(u"bold",
406
u"default", u"default", u"bold"),
407
(u"underline-blink",
408
u"default", u"default", u"underline"),
409
(u"standout",
410
u"default", u"default", u"standout"),
411
(u"bold-underline-blink",
412
u"default", u"default", (u"bold", u"underline")),
413
(u"bold-standout",
414
u"default", u"default", (u"bold", u"standout")),
415
(u"underline-blink-standout",
416
u"default", u"default", (u"underline", u"standout")),
417
(u"bold-underline-blink-standout",
418
u"default", u"default", (u"bold", u"underline",
419
u"standout")),
420
))
421
422
if urwid.supports_unicode():
423
self.divider = u"─" # \u2500
424
#self.divider = u"━" # \u2501
425
else:
426
#self.divider = u"-" # \u002d
427
self.divider = u"_" # \u005f
428
429
self.screen.start()
430
431
self.size = self.screen.get_cols_rows()
432
433
self.clients = urwid.SimpleListWalker([])
434
self.clients_dict = {}
435
436
# We will add Text widgets to this list
437
self.log = []
438
self.max_log_length = max_log_length
439
440
# We keep a reference to the log widget so we can remove it
441
# from the ListWalker without it getting destroyed
442
self.logbox = ConstrainedListBox(self.log)
443
444
# This keeps track of whether self.uilist currently has
445
# self.logbox in it or not
446
self.log_visible = True
447
self.log_wrap = u"any"
448
449
self.rebuild()
450
self.log_message_raw((u"bold",
451
u"Mandos Monitor version " + version))
452
self.log_message_raw((u"bold",
453
u"q: Quit ?: Help"))
454
455
self.busname = domain + '.Mandos'
456
self.main_loop = gobject.MainLoop()
457
self.bus = dbus.SystemBus()
458
mandos_dbus_objc = self.bus.get_object(
459
self.busname, u"/", follow_name_owner_changes=True)
460
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
461
dbus_interface
462
= server_interface)
463
try:
464
mandos_clients = (self.mandos_serv
465
.GetAllClientsWithProperties())
466
except dbus.exceptions.DBusException:
467
mandos_clients = dbus.Dictionary()
468
469
(self.mandos_serv
470
.connect_to_signal(u"ClientRemoved",
471
self.find_and_remove_client,
472
dbus_interface=server_interface,
473
byte_arrays=True))
474
(self.mandos_serv
475
.connect_to_signal(u"ClientAdded",
476
self.add_new_client,
477
dbus_interface=server_interface,
478
byte_arrays=True))
479
(self.mandos_serv
480
.connect_to_signal(u"ClientNotFound",
481
self.client_not_found,
482
dbus_interface=server_interface,
483
byte_arrays=True))
484
for path, client in mandos_clients.iteritems():
485
client_proxy_object = self.bus.get_object(self.busname,
486
path)
487
self.add_client(MandosClientWidget(server_proxy_object
488
=self.mandos_serv,
489
proxy_object
490
=client_proxy_object,
491
properties=client,
492
update_hook
493
=self.refresh,
494
delete_hook
495
=self.remove_client,
496
logger
497
=self.log_message),
498
path=path)
499
500
def client_not_found(self, fingerprint, address):
501
self.log_message((u"Client with address %s and fingerprint %s"
502
u" could not be found" % (address,
503
fingerprint)))
504
505
def rebuild(self):
506
"""This rebuilds the User Interface.
507
Call this when the widget layout needs to change"""
508
self.uilist = []
509
#self.uilist.append(urwid.ListBox(self.clients))
510
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
511
clients),
512
#header=urwid.Divider(),
513
header=None,
514
footer=
515
urwid.Divider(div_char=
516
self.divider)))
517
if self.log_visible:
518
self.uilist.append(self.logbox)
519
pass
520
self.topwidget = urwid.Pile(self.uilist)
521
522
def log_message(self, message):
523
timestamp = datetime.datetime.now().isoformat()
524
self.log_message_raw(timestamp + u": " + message)
525
526
def log_message_raw(self, markup):
527
"""Add a log message to the log buffer."""
528
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
529
if (self.max_log_length
530
and len(self.log) > self.max_log_length):
531
del self.log[0:len(self.log)-self.max_log_length-1]
532
self.logbox.set_focus(len(self.logbox.body.contents),
533
coming_from=u"above")
534
self.refresh()
535
536
def toggle_log_display(self):
537
"""Toggle visibility of the log buffer."""
538
self.log_visible = not self.log_visible
539
self.rebuild()
540
#self.log_message(u"Log visibility changed to: "
541
# + unicode(self.log_visible))
542
543
def change_log_display(self):
544
"""Change type of log display.
545
Currently, this toggles wrapping of text lines."""
546
if self.log_wrap == u"clip":
547
self.log_wrap = u"any"
548
else:
549
self.log_wrap = u"clip"
550
for textwidget in self.log:
551
textwidget.set_wrap_mode(self.log_wrap)
552
#self.log_message(u"Wrap mode: " + self.log_wrap)
553
554
def find_and_remove_client(self, path, name):
555
"""Find an client from its object path and remove it.
556
557
This is connected to the ClientRemoved signal from the
558
Mandos server object."""
559
try:
560
client = self.clients_dict[path]
561
except KeyError:
562
# not found?
563
return
564
self.remove_client(client, path)
565
566
def add_new_client(self, path):
567
client_proxy_object = self.bus.get_object(self.busname, path)
568
self.add_client(MandosClientWidget(server_proxy_object
569
=self.mandos_serv,
570
proxy_object
571
=client_proxy_object,
572
update_hook
573
=self.refresh,
574
delete_hook
575
=self.remove_client,
576
logger
577
=self.log_message),
578
path=path)
579
580
def add_client(self, client, path=None):
581
self.clients.append(client)
582
if path is None:
583
path = client.proxy.object_path
584
self.clients_dict[path] = client
585
self.clients.sort(None, lambda c: c.properties[u"Name"])
586
self.refresh()
587
588
def remove_client(self, client, path=None):
589
self.clients.remove(client)
590
if path is None:
591
path = client.proxy.object_path
592
del self.clients_dict[path]
593
if not self.clients_dict:
594
# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
595
# is completely emptied, we need to recreate it.
596
self.clients = urwid.SimpleListWalker([])
597
self.rebuild()
598
self.refresh()
599
600
def refresh(self):
601
"""Redraw the screen"""
602
canvas = self.topwidget.render(self.size, focus=True)
603
self.screen.draw_screen(self.size, canvas)
604
605
def run(self):
606
"""Start the main loop and exit when it's done."""
607
self.refresh()
608
self._input_callback_tag = (gobject.io_add_watch
609
(sys.stdin.fileno(),
610
gobject.IO_IN,
611
self.process_input))
612
self.main_loop.run()
613
# Main loop has finished, we should close everything now
614
gobject.source_remove(self._input_callback_tag)
615
self.screen.stop()
616
617
def stop(self):
618
self.main_loop.quit()
619
620
def process_input(self, source, condition):
621
keys = self.screen.get_input()
622
translations = { u"ctrl n": u"down", # Emacs
623
u"ctrl p": u"up", # Emacs
624
u"ctrl v": u"page down", # Emacs
625
u"meta v": u"page up", # Emacs
626
u" ": u"page down", # less
627
u"f": u"page down", # less
628
u"b": u"page up", # less
629
u"j": u"down", # vi
630
u"k": u"up", # vi
631
}
632
for key in keys:
633
try:
634
key = translations[key]
635
except KeyError: # :-)
636
pass
637
638
if key == u"q" or key == u"Q":
639
self.stop()
640
break
641
elif key == u"window resize":
642
self.size = self.screen.get_cols_rows()
643
self.refresh()
644
elif key == u"\f": # Ctrl-L
645
self.refresh()
646
elif key == u"l" or key == u"D":
647
self.toggle_log_display()
648
self.refresh()
649
elif key == u"w" or key == u"i":
650
self.change_log_display()
651
self.refresh()
652
elif key == u"?" or key == u"f1" or key == u"esc":
653
if not self.log_visible:
654
self.log_visible = True
655
self.rebuild()
656
self.log_message_raw((u"bold",
657
u" ".
658
join((u"q: Quit",
659
u"?: Help",
660
u"l: Log window toggle",
661
u"TAB: Switch window",
662
u"w: Wrap (log)"))))
663
self.log_message_raw((u"bold",
664
u" "
665
.join((u"Clients:",
666
u"+: Enable",
667
u"-: Disable",
668
u"r: Remove",
669
u"s: Start new checker",
670
u"S: Stop checker",
671
u"C: Checker OK",
672
u"a: Approve",
673
u"d: Deny"))))
674
self.refresh()
675
elif key == u"tab":
676
if self.topwidget.get_focus() is self.logbox:
677
self.topwidget.set_focus(0)
678
else:
679
self.topwidget.set_focus(self.logbox)
680
self.refresh()
681
#elif (key == u"end" or key == u"meta >" or key == u"G"
682
# or key == u">"):
683
# pass # xxx end-of-buffer
684
#elif (key == u"home" or key == u"meta <" or key == u"g"
685
# or key == u"<"):
686
# pass # xxx beginning-of-buffer
687
#elif key == u"ctrl e" or key == u"$":
688
# pass # xxx move-end-of-line
689
#elif key == u"ctrl a" or key == u"^":
690
# pass # xxx move-beginning-of-line
691
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
692
# pass # xxx left
693
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
694
# pass # xxx right
695
#elif key == u"a":
696
# pass # scroll up log
697
#elif key == u"z":
698
# pass # scroll down log
699
elif self.topwidget.selectable():
700
self.topwidget.keypress(self.size, key)
701
self.refresh()
702
return True
703
704
ui = UserInterface()
705
try:
706
ui.run()
707
except KeyboardInterrupt:
708
ui.screen.stop()
709
except Exception, e:
710
ui.log_message(unicode(e))
711
ui.screen.stop()
712
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0