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 406
- compare with another revision
- download diff
- download tarball
- view history from revision 406
- Committer: Teddy Hogeborn
- Date: 2009-11-09 07:35:16 UTC
- Revision ID: teddy@fukt.bsnet.se-20091109073516-v1vem352uz0vuwrd
* dbus-mandos.conf: New; to be copied to
"/etc/dbus-1/system.d/mandos.conf".
"/etc/dbus-1/system.d/mandos.conf".
added
removed
mandos-monitor
1
1
#!/usr/bin/python
2
2
# -*- mode: python; coding: utf-8 -*-
3
#
4
# Mandos Monitor - Control and monitor the Mandos server
5
#
6
# Copyright © 2009,2010 Teddy Hogeborn
7
# Copyright © 2009,2010 Björn Påhlsson
8
#
9
# This program is free software: you can redistribute it and/or modify
10
# it under the terms of the GNU General Public License as published by
11
# the Free Software Foundation, either version 3 of the License, or
12
# (at your option) any later version.
13
#
14
# This program is distributed in the hope that it will be useful,
15
# but WITHOUT ANY WARRANTY; without even the implied warranty of
16
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17
# GNU General Public License for more details.
18
#
19
# You should have received a copy of the GNU General Public License
20
# along with this program. If not, see <http://www.gnu.org/licenses/>.
21
#
22
# Contact the authors at <mandos@fukt.bsnet.se>.
23
#
24
3
25
4
from __future__ import division, absolute_import, with_statement
26
5
27
6
import sys
28
import os
29
7
import signal
30
8
31
import datetime
32
33
9
import urwid.curses_display
34
10
import urwid
35
11
40
16
41
17
import UserList
42
18
43
import locale
44
45
locale.setlocale(locale.LC_ALL, u'')
46
47
import logging
48
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
49
50
19
# Some useful constants
51
20
domain = 'se.bsnet.fukt'
52
21
server_interface = domain + '.Mandos'
53
22
client_interface = domain + '.Mandos.Client'
54
version = "1.0.15"
23
version = "1.0.14"
55
24
56
25
# Always run in monochrome mode
57
26
urwid.curses_display.curses.has_colors = lambda : False
61
30
urwid.curses_display.curses.A_UNDERLINE |= (
62
31
urwid.curses_display.curses.A_BLINK)
63
32
64
def isoformat_to_datetime(iso):
65
"Parse an ISO 8601 date string to a datetime.datetime()"
66
if not iso:
67
return None
68
d, t = iso.split(u"T", 1)
69
year, month, day = d.split(u"-", 2)
70
hour, minute, second = t.split(u":", 2)
71
second, fraction = divmod(float(second), 1)
72
return datetime.datetime(int(year),
73
int(month),
74
int(day),
75
int(hour),
76
int(minute),
77
int(second), # Whole seconds
78
int(fraction*1000000)) # Microseconds
79
80
33
class MandosClientPropertyCache(object):
81
34
"""This wraps a Mandos Client D-Bus proxy object, caches the
82
35
properties and calls a hook function when any of them are
83
36
changed.
84
37
"""
85
def __init__(self, proxy_object=None, *args, **kwargs):
38
def __init__(self, proxy_object=None, properties=None, *args,
39
**kwargs):
86
40
self.proxy = proxy_object # Mandos Client proxy object
87
41
88
self.properties = dict()
89
self.proxy.connect_to_signal(u"PropertyChanged",
42
if properties is None:
43
self.properties = dict()
44
else:
45
self.properties = properties
46
self.proxy.connect_to_signal("PropertyChanged",
90
47
self.property_changed,
91
48
client_interface,
92
49
byte_arrays=True)
93
50
94
self.properties.update(
95
self.proxy.GetAll(client_interface,
96
dbus_interface = dbus.PROPERTIES_IFACE))
97
98
#XXX This break good super behaviour!
99
# super(MandosClientPropertyCache, self).__init__(
100
# *args, **kwargs)
51
if properties is None:
52
self.properties.update(self.proxy.GetAll(client_interface,
53
dbus_interface =
54
dbus.PROPERTIES_IFACE))
55
super(MandosClientPropertyCache, self).__init__(
56
proxy_object=proxy_object,
57
properties=properties, *args, **kwargs)
101
58
102
59
def property_changed(self, property=None, value=None):
103
60
"""This is called whenever we get a PropertyChanged signal
112
69
"""
113
70
114
71
def __init__(self, server_proxy_object=None, update_hook=None,
115
delete_hook=None, logger=None, *args, **kwargs):
72
delete_hook=None, *args, **kwargs):
116
73
# Called on update
117
74
self.update_hook = update_hook
118
75
# Called on delete
119
76
self.delete_hook = delete_hook
120
77
# Mandos Server proxy object
121
78
self.server_proxy_object = server_proxy_object
122
# Logger
123
self.logger = logger
124
125
self._update_timer_callback_tag = None
126
self._update_timer_callback_lock = 0
127
self.last_checker_failed = False
128
79
129
80
# The widget shown normally
130
self._text_widget = urwid.Text(u"")
81
self._text_widget = urwid.Text("")
131
82
# The widget shown when we have focus
132
self._focus_text_widget = urwid.Text(u"")
83
self._focus_text_widget = urwid.Text("")
133
84
super(MandosClientWidget, self).__init__(
134
85
update_hook=update_hook, delete_hook=delete_hook,
135
86
*args, **kwargs)
136
87
self.update()
137
88
self.opened = False
138
139
last_checked_ok = isoformat_to_datetime(self.properties
140
[u"LastCheckedOK"])
141
if last_checked_ok is None:
142
self.last_checker_failed = True
143
else:
144
self.last_checker_failed = ((datetime.datetime.utcnow()
145
- last_checked_ok)
146
> datetime.timedelta
147
(milliseconds=
148
self.properties
149
[u"Interval"]))
150
151
if self.last_checker_failed:
152
self.using_timer(True)
153
154
if self.need_approval:
155
self.using_timer(True)
156
157
self.proxy.connect_to_signal(u"CheckerCompleted",
158
self.checker_completed,
159
client_interface,
160
byte_arrays=True)
161
self.proxy.connect_to_signal(u"CheckerStarted",
162
self.checker_started,
163
client_interface,
164
byte_arrays=True)
165
self.proxy.connect_to_signal(u"GotSecret",
166
self.got_secret,
167
client_interface,
168
byte_arrays=True)
169
self.proxy.connect_to_signal(u"NeedApproval",
170
self.need_approval,
171
client_interface,
172
byte_arrays=True)
173
self.proxy.connect_to_signal(u"Rejected",
174
self.rejected,
175
client_interface,
176
byte_arrays=True)
177
178
def property_changed(self, property=None, value=None):
179
super(self, MandosClientWidget).property_changed(property,
180
value)
181
if property == u"ApprovalPending":
182
using_timer(bool(value))
183
184
def using_timer(self, flag):
185
"""Call this method with True or False when timer should be
186
activated or deactivated.
187
"""
188
old = self._update_timer_callback_lock
189
if flag:
190
self._update_timer_callback_lock += 1
191
else:
192
self._update_timer_callback_lock -= 1
193
if old == 0 and self._update_timer_callback_lock:
194
self._update_timer_callback_tag = (gobject.timeout_add
195
(1000,
196
self.update_timer))
197
elif old and self._update_timer_callback_lock == 0:
198
gobject.source_remove(self._update_timer_callback_tag)
199
self._update_timer_callback_tag = None
200
201
def checker_completed(self, exitstatus, condition, command):
202
if exitstatus == 0:
203
if self.last_checker_failed:
204
self.last_checker_failed = False
205
self.using_timer(False)
206
#self.logger(u'Checker for client %s (command "%s")'
207
# u' was successful'
208
# % (self.properties[u"Name"], command))
209
self.update()
210
return
211
# Checker failed
212
if not self.last_checker_failed:
213
self.last_checker_failed = True
214
self.using_timer(True)
215
if os.WIFEXITED(condition):
216
self.logger(u'Checker for client %s (command "%s")'
217
u' failed with exit code %s'
218
% (self.properties[u"Name"], command,
219
os.WEXITSTATUS(condition)))
220
elif os.WIFSIGNALED(condition):
221
self.logger(u'Checker for client %s (command "%s")'
222
u' was killed by signal %s'
223
% (self.properties[u"Name"], command,
224
os.WTERMSIG(condition)))
225
elif os.WCOREDUMP(condition):
226
self.logger(u'Checker for client %s (command "%s")'
227
u' dumped core'
228
% (self.properties[u"Name"], command))
229
else:
230
self.logger(u'Checker for client %s completed'
231
u' mysteriously')
232
self.update()
233
234
def checker_started(self, command):
235
#self.logger(u'Client %s started checker "%s"'
236
# % (self.properties[u"Name"], unicode(command)))
237
pass
238
239
def got_secret(self):
240
self.last_checker_failed = False
241
self.logger(u'Client %s received its secret'
242
% self.properties[u"Name"])
243
244
def need_approval(self, timeout, default):
245
if not default:
246
message = u'Client %s needs approval within %s seconds'
247
else:
248
message = u'Client %s will get its secret in %s seconds'
249
self.logger(message
250
% (self.properties[u"Name"], timeout/1000))
251
self.using_timer(True)
252
253
def rejected(self, reason):
254
self.logger(u'Client %s was rejected; reason: %s'
255
% (self.properties[u"Name"], reason))
256
89
257
90
def selectable(self):
258
91
"""Make this a "selectable" widget.
280
113
u"bold-underline-blink":
281
114
u"bold-underline-blink-standout",
282
115
}
283
116
284
117
# Rebuild focus and non-focus widgets using current properties
285
286
# Base part of a client. Name!
287
base = (u'%(name)s: '
288
% {u"name": self.properties[u"Name"]})
289
if not self.properties[u"Enabled"]:
290
message = u"DISABLED"
291
elif self.properties[u"ApprovalPending"]:
292
timeout = datetime.timedelta(milliseconds
293
= self.properties
294
[u"ApprovalDelay"])
295
last_approval_request = isoformat_to_datetime(
296
self.properties[u"LastApprovalRequest"])
297
if last_approval_request is not None:
298
timer = timeout - (datetime.datetime.utcnow()
299
- last_approval_request)
300
else:
301
timer = datetime.timedelta()
302
if self.properties[u"ApprovedByDefault"]:
303
message = u"Approval in %s. (d)eny?"
304
else:
305
message = u"Denial in %s. (a)pprove?"
306
message = message % unicode(timer).rsplit(".", 1)[0]
307
elif self.last_checker_failed:
308
timeout = datetime.timedelta(milliseconds
309
= self.properties
310
[u"Timeout"])
311
last_ok = isoformat_to_datetime(
312
max((self.properties[u"LastCheckedOK"]
313
or self.properties[u"Created"]),
314
self.properties[u"LastEnabled"]))
315
timer = timeout - (datetime.datetime.utcnow() - last_ok)
316
message = (u'A checker has failed! Time until client'
317
u' gets disabled: %s'
318
% unicode(timer).rsplit(".", 1)[0])
319
else:
320
message = u"enabled"
321
self._text = "%s%s" % (base, message)
322
118
self._text = (u'name="%(name)s", enabled=%(enabled)s'
119
% self.properties)
323
120
if not urwid.supports_unicode():
324
121
self._text = self._text.encode("ascii", "replace")
325
textlist = [(u"normal", self._text)]
122
textlist = [(u"normal", u"BLARGH: "), (u"bold", self._text)]
326
123
self._text_widget.set_text(textlist)
327
124
self._focus_text_widget.set_text([(with_standout[text[0]],
328
125
text[1])
336
133
if self.update_hook is not None:
337
134
self.update_hook()
338
135
339
def update_timer(self):
340
"called by gobject"
341
self.update()
342
return True # Keep calling this
343
344
136
def delete(self):
345
if self._update_timer_callback_tag is not None:
346
gobject.source_remove(self._update_timer_callback_tag)
347
self._update_timer_callback_tag = None
348
137
if self.delete_hook is not None:
349
138
self.delete_hook(self)
350
139
357
146
def keypress(self, (maxcol,), key):
358
147
"""Handle keys.
359
148
This overrides the method from urwid.FlowWidget"""
360
if key == u"+":
361
self.proxy.Enable(dbus_interface = client_interface)
362
elif key == u"-":
363
self.proxy.Disable(dbus_interface = client_interface)
364
elif key == u"a":
365
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
366
dbus_interface = client_interface)
367
elif key == u"d":
368
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
369
dbus_interface = client_interface)
370
elif key == u"R" or key == u"_" or key == u"ctrl k":
149
if key == u"e" or key == u"+":
150
self.proxy.Enable()
151
elif key == u"d" or key == u"-":
152
self.proxy.Disable()
153
elif key == u"r" or key == u"_":
371
154
self.server_proxy_object.RemoveClient(self.proxy
372
155
.object_path)
373
156
elif key == u"s":
374
self.proxy.StartChecker(dbus_interface = client_interface)
157
self.proxy.StartChecker()
158
elif key == u"c":
159
self.proxy.StopChecker()
375
160
elif key == u"S":
376
self.proxy.StopChecker(dbus_interface = client_interface)
377
elif key == u"C":
378
self.proxy.CheckedOK(dbus_interface = client_interface)
161
self.proxy.CheckedOK()
379
162
# xxx
380
163
# elif key == u"p" or key == "=":
381
164
# self.proxy.pause()
404
187
use them as an excuse to shift focus away from this widget.
405
188
"""
406
189
def keypress(self, (maxcol, maxrow), key):
407
ret = super(ConstrainedListBox, self).keypress((maxcol,
408
maxrow), key)
190
ret = super(ConstrainedListBox, self).keypress((maxcol, maxrow), key)
409
191
if ret in (u"up", u"down"):
410
192
return
411
193
return ret
441
223
))
442
224
443
225
if urwid.supports_unicode():
444
self.divider = u"─" # \u2500
445
#self.divider = u"━" # \u2501
226
#self.divider = u"─" # \u2500
227
self.divider = u"━" # \u2501
446
228
else:
447
229
#self.divider = u"-" # \u002d
448
230
self.divider = u"_" # \u005f
468
250
self.log_wrap = u"any"
469
251
470
252
self.rebuild()
471
self.log_message_raw((u"bold",
472
u"Mandos Monitor version " + version))
473
self.log_message_raw((u"bold",
474
u"q: Quit ?: Help"))
253
self.log_message(u"Message")
254
self.log_message(u"Message0 Message1 Message2 Message3 Message4 Message5 Message6 Message7 Message8 Message9")
255
self.log_message(u"Message10 Message11 Message12 Message13 Message14 Message15 Message16 Message17 Message18 Message19")
256
self.log_message(u"Message20 Message21 Message22 Message23 Message24 Message25 Message26 Message27 Message28 Message29")
475
257
476
258
self.busname = domain + '.Mandos'
477
259
self.main_loop = gobject.MainLoop()
488
270
mandos_clients = dbus.Dictionary()
489
271
490
272
(self.mandos_serv
491
.connect_to_signal(u"ClientRemoved",
273
.connect_to_signal("ClientRemoved",
492
274
self.find_and_remove_client,
493
275
dbus_interface=server_interface,
494
276
byte_arrays=True))
495
277
(self.mandos_serv
496
.connect_to_signal(u"ClientAdded",
278
.connect_to_signal("ClientAdded",
497
279
self.add_new_client,
498
280
dbus_interface=server_interface,
499
281
byte_arrays=True))
500
(self.mandos_serv
501
.connect_to_signal(u"ClientNotFound",
502
self.client_not_found,
503
dbus_interface=server_interface,
504
byte_arrays=True))
505
282
for path, client in mandos_clients.iteritems():
506
283
client_proxy_object = self.bus.get_object(self.busname,
507
284
path)
513
290
update_hook
514
291
=self.refresh,
515
292
delete_hook
516
=self.remove_client,
517
logger
518
=self.log_message),
293
=self.remove_client),
519
294
path=path)
520
295
521
def client_not_found(self, fingerprint, address):
522
self.log_message((u"Client with address %s and fingerprint %s"
523
u" could not be found" % (address,
524
fingerprint)))
525
526
296
def rebuild(self):
527
297
"""This rebuilds the User Interface.
528
298
Call this when the widget layout needs to change"""
529
299
self.uilist = []
530
300
#self.uilist.append(urwid.ListBox(self.clients))
531
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
532
clients),
301
self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),
533
302
#header=urwid.Divider(),
534
303
header=None,
535
footer=
536
urwid.Divider(div_char=
537
self.divider)))
304
footer=urwid.Divider(div_char=self.divider)))
538
305
if self.log_visible:
539
306
self.uilist.append(self.logbox)
540
307
pass
541
308
self.topwidget = urwid.Pile(self.uilist)
542
309
543
def log_message(self, message):
544
timestamp = datetime.datetime.now().isoformat()
545
self.log_message_raw(timestamp + u": " + message)
546
547
def log_message_raw(self, markup):
310
def log_message(self, markup):
548
311
"""Add a log message to the log buffer."""
549
312
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
550
313
if (self.max_log_length
551
314
and len(self.log) > self.max_log_length):
552
315
del self.log[0:len(self.log)-self.max_log_length-1]
553
self.logbox.set_focus(len(self.logbox.body.contents),
554
coming_from=u"above")
555
self.refresh()
556
316
557
317
def toggle_log_display(self):
558
318
"""Toggle visibility of the log buffer."""
559
319
self.log_visible = not self.log_visible
560
320
self.rebuild()
561
#self.log_message(u"Log visibility changed to: "
562
# + unicode(self.log_visible))
321
self.log_message(u"Log visibility changed to: "
322
+ unicode(self.log_visible))
563
323
564
324
def change_log_display(self):
565
325
"""Change type of log display.
570
330
self.log_wrap = u"clip"
571
331
for textwidget in self.log:
572
332
textwidget.set_wrap_mode(self.log_wrap)
573
#self.log_message(u"Wrap mode: " + self.log_wrap)
333
self.log_message(u"Wrap mode: " + self.log_wrap)
574
334
575
335
def find_and_remove_client(self, path, name):
576
336
"""Find an client from its object path and remove it.
584
344
return
585
345
self.remove_client(client, path)
586
346
587
def add_new_client(self, path):
347
def add_new_client(self, path, properties):
588
348
client_proxy_object = self.bus.get_object(self.busname, path)
589
349
self.add_client(MandosClientWidget(server_proxy_object
590
350
=self.mandos_serv,
591
351
proxy_object
592
352
=client_proxy_object,
353
properties=properties,
593
354
update_hook
594
355
=self.refresh,
595
356
delete_hook
596
=self.remove_client,
597
logger
598
=self.log_message),
357
=self.remove_client),
599
358
path=path)
600
359
601
360
def add_client(self, client, path=None):
603
362
if path is None:
604
363
path = client.proxy.object_path
605
364
self.clients_dict[path] = client
606
self.clients.sort(None, lambda c: c.properties[u"Name"])
365
self.clients.sort(None, lambda c: c.properties[u"name"])
607
366
self.refresh()
608
367
609
368
def remove_client(self, client, path=None):
670
429
elif key == u"w" or key == u"i":
671
430
self.change_log_display()
672
431
self.refresh()
673
elif key == u"?" or key == u"f1" or key == u"esc":
674
if not self.log_visible:
675
self.log_visible = True
676
self.rebuild()
677
self.log_message_raw((u"bold",
678
u" ".
679
join((u"q: Quit",
680
u"?: Help",
681
u"l: Log window toggle",
682
u"TAB: Switch window",
683
u"w: Wrap (log)"))))
684
self.log_message_raw((u"bold",
685
u" "
686
.join((u"Clients:",
687
u"+: Enable",
688
u"-: Disable",
689
u"R: Remove",
690
u"s: Start new checker",
691
u"S: Stop checker",
692
u"C: Checker OK",
693
u"a: Approve",
694
u"d: Deny"))))
432
elif key == u"?" or key == u"f1":
433
self.log_message(u"Help!")
695
434
self.refresh()
696
435
elif key == u"tab":
697
436
if self.topwidget.get_focus() is self.logbox:
699
438
else:
700
439
self.topwidget.set_focus(self.logbox)
701
440
self.refresh()
702
#elif (key == u"end" or key == u"meta >" or key == u"G"
703
# or key == u">"):
704
# pass # xxx end-of-buffer
705
#elif (key == u"home" or key == u"meta <" or key == u"g"
706
# or key == u"<"):
707
# pass # xxx beginning-of-buffer
708
#elif key == u"ctrl e" or key == u"$":
709
# pass # xxx move-end-of-line
710
#elif key == u"ctrl a" or key == u"^":
711
# pass # xxx move-beginning-of-line
712
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
713
# pass # xxx left
714
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
715
# pass # xxx right
716
#elif key == u"a":
717
# pass # scroll up log
718
#elif key == u"z":
719
# pass # scroll down log
441
elif (key == u"end" or key == u"meta >" or key == u"G"
442
or key == u">"):
443
pass # xxx end-of-buffer
444
elif (key == u"home" or key == u"meta <" or key == u"g"
445
or key == u"<"):
446
pass # xxx beginning-of-buffer
447
elif key == u"ctrl e" or key == u"$":
448
pass # xxx move-end-of-line
449
elif key == u"ctrl a" or key == u"^":
450
pass # xxx move-beginning-of-line
451
elif key == u"ctrl b" or key == u"meta (" or key == u"h":
452
pass # xxx left
453
elif key == u"ctrl f" or key == u"meta )" or key == u"l":
454
pass # xxx right
455
elif key == u"a":
456
pass # scroll up log
457
elif key == u"z":
458
pass # scroll down log
720
459
elif self.topwidget.selectable():
721
460
self.topwidget.keypress(self.size, key)
722
461
self.refresh()
725
464
ui = UserInterface()
726
465
try:
727
466
ui.run()
728
except KeyboardInterrupt:
729
ui.screen.stop()
730
except Exception, e:
731
ui.log_message(unicode(e))
467
except:
732
468
ui.screen.stop()
733
469
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0