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 200
- compare with another revision
- download diff
- download tarball
- view history from revision 200
- Committer: Teddy Hogeborn
- Date: 2008-09-21 12:04:02 UTC
- Revision ID: teddy@fukt.bsnet.se-20080921120402-mgd2jl8xo634jw18
* Makefile: Put the init script before avahi-daemon.
* debian/mandos.prerm: Bug fix: stop mandos, not ssh.
* debian/rules (install-indep): Put the init script before
avahi-daemon.
* init.d/mandos: Require "avahi-daemon".
* debian/mandos.prerm: Bug fix: stop mandos, not ssh.
* debian/rules (install-indep): Put the init script before
avahi-daemon.
* init.d/mandos: Require "avahi-daemon".
- files added:
- debian/mandos-client.config
- files removed:
- DBUS-API
- files modified:
- .bzrignore
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.last_checker_failed = False
106
107
# The widget shown normally
108
self._text_widget = urwid.Text(u"")
109
# The widget shown when we have focus
110
self._focus_text_widget = urwid.Text(u"")
111
super(MandosClientWidget, self).__init__(
112
update_hook=update_hook, delete_hook=delete_hook,
113
*args, **kwargs)
114
self.update()
115
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
210
def selectable(self):
211
"""Make this a "selectable" widget.
212
This overrides the method from urwid.FlowWidget."""
213
return True
214
215
def rows(self, (maxcol,), focus=False):
216
"""How many rows this widget will occupy might depend on
217
whether we have focus or not.
218
This overrides the method from urwid.FlowWidget"""
219
return self.current_widget(focus).rows((maxcol,), focus=focus)
220
221
def current_widget(self, focus=False):
222
if focus or self.opened:
223
return self._focus_widget
224
return self._widget
225
226
def update(self):
227
"Called when what is visible on the screen should be updated."
228
# How to add standout mode to a style
229
with_standout = { u"normal": u"standout",
230
u"bold": u"bold-standout",
231
u"underline-blink":
232
u"underline-blink-standout",
233
u"bold-underline-blink":
234
u"bold-underline-blink-standout",
235
}
236
237
# 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
265
if not urwid.supports_unicode():
266
self._text = self._text.encode("ascii", "replace")
267
textlist = [(u"normal", self._text)]
268
self._text_widget.set_text(textlist)
269
self._focus_text_widget.set_text([(with_standout[text[0]],
270
text[1])
271
if isinstance(text, tuple)
272
else text
273
for text in textlist])
274
self._widget = self._text_widget
275
self._focus_widget = urwid.AttrWrap(self._focus_text_widget,
276
"standout")
277
# Run update hook, if any
278
if self.update_hook is not None:
279
self.update_hook()
280
281
def update_timer(self):
282
"called by gobject"
283
self.update()
284
return True # Keep calling this
285
286
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
if self.delete_hook is not None:
291
self.delete_hook(self)
292
293
def render(self, (maxcol,), focus=False):
294
"""Render differently if we have focus.
295
This overrides the method from urwid.FlowWidget"""
296
return self.current_widget(focus).render((maxcol,),
297
focus=focus)
298
299
def keypress(self, (maxcol,), key):
300
"""Handle keys.
301
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":
313
self.server_proxy_object.RemoveClient(self.proxy
314
.object_path)
315
elif key == u"s":
316
self.proxy.StartChecker(dbus_interface = client_interface)
317
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)
321
# xxx
322
# elif key == u"p" or key == "=":
323
# self.proxy.pause()
324
# elif key == u"u" or key == ":":
325
# self.proxy.unpause()
326
# elif key == u"RET":
327
# self.open()
328
else:
329
return key
330
331
def property_changed(self, property=None, value=None,
332
*args, **kwargs):
333
"""Call self.update() if old value is not new value.
334
This overrides the method from MandosClientPropertyCache"""
335
property_name = unicode(property)
336
old_value = self.properties.get(property_name)
337
super(MandosClientWidget, self).property_changed(
338
property=property, value=value, *args, **kwargs)
339
if self.properties.get(property_name) != old_value:
340
self.update()
341
342
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.
347
"""
348
def keypress(self, (maxcol, maxrow), key):
349
ret = super(ConstrainedListBox, self).keypress((maxcol,
350
maxrow), key)
351
if ret in (u"up", u"down"):
352
return
353
return ret
354
355
356
class UserInterface(object):
357
"""This is the entire user interface - the whole screen
358
with boxes, lists of client widgets, etc.
359
"""
360
def __init__(self, max_log_length=1000):
361
DBusGMainLoop(set_as_default=True)
362
363
self.screen = urwid.curses_display.Screen()
364
365
self.screen.register_palette((
366
(u"normal",
367
u"default", u"default", None),
368
(u"bold",
369
u"default", u"default", u"bold"),
370
(u"underline-blink",
371
u"default", u"default", u"underline"),
372
(u"standout",
373
u"default", u"default", u"standout"),
374
(u"bold-underline-blink",
375
u"default", u"default", (u"bold", u"underline")),
376
(u"bold-standout",
377
u"default", u"default", (u"bold", u"standout")),
378
(u"underline-blink-standout",
379
u"default", u"default", (u"underline", u"standout")),
380
(u"bold-underline-blink-standout",
381
u"default", u"default", (u"bold", u"underline",
382
u"standout")),
383
))
384
385
if urwid.supports_unicode():
386
self.divider = u"─" # \u2500
387
#self.divider = u"━" # \u2501
388
else:
389
#self.divider = u"-" # \u002d
390
self.divider = u"_" # \u005f
391
392
self.screen.start()
393
394
self.size = self.screen.get_cols_rows()
395
396
self.clients = urwid.SimpleListWalker([])
397
self.clients_dict = {}
398
399
# We will add Text widgets to this list
400
self.log = []
401
self.max_log_length = max_log_length
402
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)
406
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"
411
412
self.rebuild()
413
self.log_message_raw((u"bold",
414
u"Mandos Monitor version " + version))
415
self.log_message_raw((u"bold",
416
u"q: Quit ?: Help"))
417
418
self.busname = domain + '.Mandos'
419
self.main_loop = gobject.MainLoop()
420
self.bus = dbus.SystemBus()
421
mandos_dbus_objc = self.bus.get_object(
422
self.busname, u"/", follow_name_owner_changes=True)
423
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
424
dbus_interface
425
= server_interface)
426
try:
427
mandos_clients = (self.mandos_serv
428
.GetAllClientsWithProperties())
429
except dbus.exceptions.DBusException:
430
mandos_clients = dbus.Dictionary()
431
432
(self.mandos_serv
433
.connect_to_signal(u"ClientRemoved",
434
self.find_and_remove_client,
435
dbus_interface=server_interface,
436
byte_arrays=True))
437
(self.mandos_serv
438
.connect_to_signal(u"ClientAdded",
439
self.add_new_client,
440
dbus_interface=server_interface,
441
byte_arrays=True))
442
(self.mandos_serv
443
.connect_to_signal(u"ClientNotFound",
444
self.client_not_found,
445
dbus_interface=server_interface,
446
byte_arrays=True))
447
for path, client in mandos_clients.iteritems():
448
client_proxy_object = self.bus.get_object(self.busname,
449
path)
450
self.add_client(MandosClientWidget(server_proxy_object
451
=self.mandos_serv,
452
proxy_object
453
=client_proxy_object,
454
properties=client,
455
update_hook
456
=self.refresh,
457
delete_hook
458
=self.remove_client,
459
logger
460
=self.log_message),
461
path=path)
462
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,
466
fingerprint)))
467
468
def rebuild(self):
469
"""This rebuilds the User Interface.
470
Call this when the widget layout needs to change"""
471
self.uilist = []
472
#self.uilist.append(urwid.ListBox(self.clients))
473
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
474
clients),
475
#header=urwid.Divider(),
476
header=None,
477
footer=
478
urwid.Divider(div_char=
479
self.divider)))
480
if self.log_visible:
481
self.uilist.append(self.logbox)
482
pass
483
self.topwidget = urwid.Pile(self.uilist)
484
485
def log_message(self, message):
486
timestamp = datetime.datetime.now().isoformat()
487
self.log_message_raw(timestamp + u": " + message)
488
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")
497
self.refresh()
498
499
def toggle_log_display(self):
500
"""Toggle visibility of the log buffer."""
501
self.log_visible = not self.log_visible
502
self.rebuild()
503
#self.log_message(u"Log visibility changed to: "
504
# + unicode(self.log_visible))
505
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"
511
else:
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)
516
517
def find_and_remove_client(self, path, name):
518
"""Find an client from its object path and remove it.
519
520
This is connected to the ClientRemoved signal from the
521
Mandos server object."""
522
try:
523
client = self.clients_dict[path]
524
except KeyError:
525
# not found?
526
return
527
self.remove_client(client, path)
528
529
def add_new_client(self, path):
530
client_proxy_object = self.bus.get_object(self.busname, path)
531
self.add_client(MandosClientWidget(server_proxy_object
532
=self.mandos_serv,
533
proxy_object
534
=client_proxy_object,
535
update_hook
536
=self.refresh,
537
delete_hook
538
=self.remove_client,
539
logger
540
=self.log_message),
541
path=path)
542
543
def add_client(self, client, path=None):
544
self.clients.append(client)
545
if path is None:
546
path = client.proxy.object_path
547
self.clients_dict[path] = client
548
self.clients.sort(None, lambda c: c.properties[u"Name"])
549
self.refresh()
550
551
def remove_client(self, client, path=None):
552
self.clients.remove(client)
553
if path is None:
554
path = client.proxy.object_path
555
del self.clients_dict[path]
556
if not self.clients_dict:
557
# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
558
# is completely emptied, we need to recreate it.
559
self.clients = urwid.SimpleListWalker([])
560
self.rebuild()
561
self.refresh()
562
563
def refresh(self):
564
"""Redraw the screen"""
565
canvas = self.topwidget.render(self.size, focus=True)
566
self.screen.draw_screen(self.size, canvas)
567
568
def run(self):
569
"""Start the main loop and exit when it's done."""
570
self.refresh()
571
self._input_callback_tag = (gobject.io_add_watch
572
(sys.stdin.fileno(),
573
gobject.IO_IN,
574
self.process_input))
575
self.main_loop.run()
576
# Main loop has finished, we should close everything now
577
gobject.source_remove(self._input_callback_tag)
578
self.screen.stop()
579
580
def stop(self):
581
self.main_loop.quit()
582
583
def process_input(self, source, condition):
584
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
592
u"j": u"down", # vi
593
u"k": u"up", # vi
594
}
595
for key in keys:
596
try:
597
key = translations[key]
598
except KeyError: # :-)
599
pass
600
601
if key == u"q" or key == u"Q":
602
self.stop()
603
break
604
elif key == u"window resize":
605
self.size = self.screen.get_cols_rows()
606
self.refresh()
607
elif key == u"\f": # Ctrl-L
608
self.refresh()
609
elif key == u"l" or key == u"D":
610
self.toggle_log_display()
611
self.refresh()
612
elif key == u"w" or key == u"i":
613
self.change_log_display()
614
self.refresh()
615
elif key == u"?" or key == u"f1" or key == u"esc":
616
if not self.log_visible:
617
self.log_visible = True
618
self.rebuild()
619
self.log_message_raw((u"bold",
620
u" ".
621
join((u"q: Quit",
622
u"?: Help",
623
u"l: Log window toggle",
624
u"TAB: Switch window",
625
u"w: Wrap (log)"))))
626
self.log_message_raw((u"bold",
627
u" "
628
.join((u"Clients:",
629
u"+: Enable",
630
u"-: Disable",
631
u"r: Remove",
632
u"s: Start new checker",
633
u"S: Stop checker",
634
u"C: Checker OK",
635
u"a: Approve",
636
u"d: Deny"))))
637
self.refresh()
638
elif key == u"tab":
639
if self.topwidget.get_focus() is self.logbox:
640
self.topwidget.set_focus(0)
641
else:
642
self.topwidget.set_focus(self.logbox)
643
self.refresh()
644
#elif (key == u"end" or key == u"meta >" or key == u"G"
645
# or key == u">"):
646
# pass # xxx end-of-buffer
647
#elif (key == u"home" or key == u"meta <" or key == u"g"
648
# or key == u"<"):
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":
655
# pass # xxx left
656
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
657
# pass # xxx right
658
#elif key == u"a":
659
# pass # scroll up log
660
#elif key == u"z":
661
# pass # scroll down log
662
elif self.topwidget.selectable():
663
self.topwidget.keypress(self.size, key)
664
self.refresh()
665
return True
666
667
ui = UserInterface()
668
try:
669
ui.run()
670
except KeyboardInterrupt:
671
ui.screen.stop()
672
except Exception, e:
673
ui.log_message(unicode(e))
674
ui.screen.stop()
675
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0