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 237.4.15
- compare with another revision
- download diff
- download tarball
- view history from revision 237.4.15
- Committer: Teddy Hogeborn
- Date: 2011-07-25 18:52:11 UTC
- mfrom: (489 trunk)
- mto: (237.4.29 release)
- mto: This revision was merged to the branch mainline in revision 490.
- Revision ID: teddy@fukt.bsnet.se-20110725185211-wlitr9jvs70e1xh8
Merge from trunk.
- files removed:
- debian/mandos-client.examples
- network-hooks.d
- files modified:
- .bzrignore
added
removed
mandos-monitor
3
3
#
4
4
# Mandos Monitor - Control and monitor the Mandos server
5
5
#
6
# Copyright © 2009-2012 Teddy Hogeborn
7
# Copyright © 2009-2012 Björn Påhlsson
6
# Copyright © 2009-2011 Teddy Hogeborn
7
# Copyright © 2009-2011 Björn Påhlsson
8
8
#
9
9
# This program is free software: you can redistribute it and/or modify
10
10
# it under the terms of the GNU General Public License as published by
17
17
# GNU General Public License for more details.
18
18
#
19
19
# You should have received a copy of the GNU General Public License
20
# along with this program. If not, see
21
# <http://www.gnu.org/licenses/>.
20
# along with this program. If not, see <http://www.gnu.org/licenses/>.
22
21
#
23
# Contact the authors at <mandos@recompile.se>.
22
# Contact the authors at <mandos@fukt.bsnet.se>.
24
23
#
25
24
26
25
from __future__ import (division, absolute_import, print_function,
27
26
unicode_literals)
28
try:
29
from future_builtins import *
30
except ImportError:
31
pass
32
27
33
28
import sys
34
29
import os
40
35
import urwid
41
36
42
37
from dbus.mainloop.glib import DBusGMainLoop
43
try:
44
import gobject
45
except ImportError:
46
from gi.repository import GObject as gobject
38
import gobject
47
39
48
40
import dbus
49
41
42
import UserList
43
50
44
import locale
51
45
52
if sys.version_info[0] == 2:
53
str = unicode
54
55
46
locale.setlocale(locale.LC_ALL, '')
56
47
57
48
import logging
58
49
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
59
50
60
51
# Some useful constants
61
domain = 'se.recompile'
52
domain = 'se.bsnet.fukt'
62
53
server_interface = domain + '.Mandos'
63
54
client_interface = domain + '.Mandos.Client'
64
version = "1.6.0"
55
version = "1.3.0"
56
57
# Always run in monochrome mode
58
urwid.curses_display.curses.has_colors = lambda : False
59
60
# Urwid doesn't support blinking, but we want it. Since we have no
61
# use for underline on its own, we make underline also always blink.
62
urwid.curses_display.curses.A_UNDERLINE |= (
63
urwid.curses_display.curses.A_BLINK)
65
64
66
65
def isoformat_to_datetime(iso):
67
66
"Parse an ISO 8601 date string to a datetime.datetime()"
84
83
properties and calls a hook function when any of them are
85
84
changed.
86
85
"""
87
def __init__(self, proxy_object=None, properties=None, **kwargs):
86
def __init__(self, proxy_object=None, *args, **kwargs):
88
87
self.proxy = proxy_object # Mandos Client proxy object
89
self.properties = dict() if properties is None else properties
88
89
self.properties = dict()
90
90
self.property_changed_match = (
91
91
self.proxy.connect_to_signal("PropertyChanged",
92
self._property_changed,
92
self.property_changed,
93
93
client_interface,
94
94
byte_arrays=True))
95
95
96
if properties is None:
97
self.properties.update(
98
self.proxy.GetAll(client_interface,
99
dbus_interface
100
= dbus.PROPERTIES_IFACE))
101
102
super(MandosClientPropertyCache, self).__init__(**kwargs)
103
104
def _property_changed(self, property, value):
105
"""Helper which takes positional arguments"""
106
return self.property_changed(property=property, value=value)
96
self.properties.update(
97
self.proxy.GetAll(client_interface,
98
dbus_interface = dbus.PROPERTIES_IFACE))
99
100
#XXX This breaks good super behaviour
101
# super(MandosClientPropertyCache, self).__init__(
102
# *args, **kwargs)
107
103
108
104
def property_changed(self, property=None, value=None):
109
105
"""This is called whenever we get a PropertyChanged signal
112
108
# Update properties dict with new value
113
109
self.properties[property] = value
114
110
115
def delete(self):
111
def delete(self, *args, **kwargs):
116
112
self.property_changed_match.remove()
113
super(MandosClientPropertyCache, self).__init__(
114
*args, **kwargs)
117
115
118
116
119
117
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
121
119
"""
122
120
123
121
def __init__(self, server_proxy_object=None, update_hook=None,
124
delete_hook=None, logger=None, **kwargs):
122
delete_hook=None, logger=None, *args, **kwargs):
125
123
# Called on update
126
124
self.update_hook = update_hook
127
125
# Called on delete
132
130
self.logger = logger
133
131
134
132
self._update_timer_callback_tag = None
133
self._update_timer_callback_lock = 0
134
self.last_checker_failed = False
135
135
136
136
# The widget shown normally
137
137
self._text_widget = urwid.Text("")
138
138
# The widget shown when we have focus
139
139
self._focus_text_widget = urwid.Text("")
140
super(MandosClientWidget, self).__init__(**kwargs)
140
super(MandosClientWidget, self).__init__(
141
update_hook=update_hook, delete_hook=delete_hook,
142
*args, **kwargs)
141
143
self.update()
142
144
self.opened = False
143
145
146
last_checked_ok = isoformat_to_datetime(self.properties
147
["LastCheckedOK"])
148
if last_checked_ok is None:
149
self.last_checker_failed = True
150
else:
151
self.last_checker_failed = ((datetime.datetime.utcnow()
152
- last_checked_ok)
153
> datetime.timedelta
154
(milliseconds=
155
self.properties
156
["Interval"]))
157
158
if self.last_checker_failed:
159
self.using_timer(True)
160
161
if self.need_approval:
162
self.using_timer(True)
163
144
164
self.match_objects = (
145
165
self.proxy.connect_to_signal("CheckerCompleted",
146
166
self.checker_completed,
162
182
self.rejected,
163
183
client_interface,
164
184
byte_arrays=True))
165
#self.logger('Created client {0}'
166
# .format(self.properties["Name"]))
185
#self.logger('Created client %s' % (self.properties["Name"]))
167
186
187
def property_changed(self, property=None, value=None):
188
super(self, MandosClientWidget).property_changed(property,
189
value)
190
if property == "ApprovalPending":
191
using_timer(bool(value))
192
168
193
def using_timer(self, flag):
169
194
"""Call this method with True or False when timer should be
170
195
activated or deactivated.
171
196
"""
172
if flag and self._update_timer_callback_tag is None:
173
# Will update the shown timer value every second
197
old = self._update_timer_callback_lock
198
if flag:
199
self._update_timer_callback_lock += 1
200
else:
201
self._update_timer_callback_lock -= 1
202
if old == 0 and self._update_timer_callback_lock:
174
203
self._update_timer_callback_tag = (gobject.timeout_add
175
204
(1000,
176
205
self.update_timer))
177
elif not (flag or self._update_timer_callback_tag is None):
206
elif old and self._update_timer_callback_lock == 0:
178
207
gobject.source_remove(self._update_timer_callback_tag)
179
208
self._update_timer_callback_tag = None
180
209
181
210
def checker_completed(self, exitstatus, condition, command):
182
211
if exitstatus == 0:
212
if self.last_checker_failed:
213
self.last_checker_failed = False
214
self.using_timer(False)
215
#self.logger('Checker for client %s (command "%s")'
216
# ' was successful'
217
# % (self.properties["Name"], command))
183
218
self.update()
184
219
return
185
220
# Checker failed
221
if not self.last_checker_failed:
222
self.last_checker_failed = True
223
self.using_timer(True)
186
224
if os.WIFEXITED(condition):
187
self.logger('Checker for client {0} (command "{1}")'
188
' failed with exit code {2}'
189
.format(self.properties["Name"], command,
190
os.WEXITSTATUS(condition)))
225
self.logger('Checker for client %s (command "%s")'
226
' failed with exit code %s'
227
% (self.properties["Name"], command,
228
os.WEXITSTATUS(condition)))
191
229
elif os.WIFSIGNALED(condition):
192
self.logger('Checker for client {0} (command "{1}") was'
193
' killed by signal {2}'
194
.format(self.properties["Name"], command,
195
os.WTERMSIG(condition)))
230
self.logger('Checker for client %s (command "%s")'
231
' was killed by signal %s'
232
% (self.properties["Name"], command,
233
os.WTERMSIG(condition)))
196
234
elif os.WCOREDUMP(condition):
197
self.logger('Checker for client {0} (command "{1}")'
235
self.logger('Checker for client %s (command "%s")'
198
236
' dumped core'
199
.format(self.properties["Name"], command))
237
% (self.properties["Name"], command))
200
238
else:
201
self.logger('Checker for client {0} completed'
202
' mysteriously'
203
.format(self.properties["Name"]))
239
self.logger('Checker for client %s completed'
240
' mysteriously')
204
241
self.update()
205
242
206
243
def checker_started(self, command):
207
"""Server signals that a checker started. This could be useful
208
to log in the future. """
209
#self.logger('Client {0} started checker "{1}"'
210
# .format(self.properties["Name"],
211
# str(command)))
244
#self.logger('Client %s started checker "%s"'
245
# % (self.properties["Name"], unicode(command)))
212
246
pass
213
247
214
248
def got_secret(self):
215
self.logger('Client {0} received its secret'
216
.format(self.properties["Name"]))
249
self.last_checker_failed = False
250
self.logger('Client %s received its secret'
251
% self.properties["Name"])
217
252
218
253
def need_approval(self, timeout, default):
219
254
if not default:
220
message = 'Client {0} needs approval within {1} seconds'
255
message = 'Client %s needs approval within %s seconds'
221
256
else:
222
message = 'Client {0} will get its secret in {1} seconds'
223
self.logger(message.format(self.properties["Name"],
224
timeout/1000))
257
message = 'Client %s will get its secret in %s seconds'
258
self.logger(message
259
% (self.properties["Name"], timeout/1000))
260
self.using_timer(True)
225
261
226
262
def rejected(self, reason):
227
self.logger('Client {0} was rejected; reason: {1}'
228
.format(self.properties["Name"], reason))
263
self.logger('Client %s was rejected; reason: %s'
264
% (self.properties["Name"], reason))
229
265
230
266
def selectable(self):
231
267
"""Make this a "selectable" widget.
253
289
"bold-underline-blink":
254
290
"bold-underline-blink-standout",
255
291
}
256
292
257
293
# Rebuild focus and non-focus widgets using current properties
258
294
259
295
# Base part of a client. Name!
260
base = '{name}: '.format(name=self.properties["Name"])
296
base = ('%(name)s: '
297
% {"name": self.properties["Name"]})
261
298
if not self.properties["Enabled"]:
262
299
message = "DISABLED"
263
self.using_timer(False)
264
300
elif self.properties["ApprovalPending"]:
265
301
timeout = datetime.timedelta(milliseconds
266
302
= self.properties
268
304
last_approval_request = isoformat_to_datetime(
269
305
self.properties["LastApprovalRequest"])
270
306
if last_approval_request is not None:
271
timer = max(timeout - (datetime.datetime.utcnow()
272
- last_approval_request),
273
datetime.timedelta())
307
timer = timeout - (datetime.datetime.utcnow()
308
- last_approval_request)
274
309
else:
275
310
timer = datetime.timedelta()
276
311
if self.properties["ApprovedByDefault"]:
277
message = "Approval in {0}. (d)eny?"
278
else:
279
message = "Denial in {0}. (a)pprove?"
280
message = message.format(str(timer).rsplit(".", 1)[0])
281
self.using_timer(True)
282
elif self.properties["LastCheckerStatus"] != 0:
283
# When checker has failed, show timer until client expires
284
expires = self.properties["Expires"]
285
if expires == "":
286
timer = datetime.timedelta(0)
287
else:
288
expires = (datetime.datetime.strptime
289
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
290
timer = max(expires - datetime.datetime.utcnow(),
291
datetime.timedelta())
312
message = "Approval in %s. (d)eny?"
313
else:
314
message = "Denial in %s. (a)pprove?"
315
message = message % unicode(timer).rsplit(".", 1)[0]
316
elif self.last_checker_failed:
317
timeout = datetime.timedelta(milliseconds
318
= self.properties
319
["Timeout"])
320
last_ok = isoformat_to_datetime(
321
max((self.properties["LastCheckedOK"]
322
or self.properties["Created"]),
323
self.properties["LastEnabled"]))
324
timer = timeout - (datetime.datetime.utcnow() - last_ok)
292
325
message = ('A checker has failed! Time until client'
293
' gets disabled: {0}'
294
.format(str(timer).rsplit(".", 1)[0]))
295
self.using_timer(True)
326
' gets disabled: %s'
327
% unicode(timer).rsplit(".", 1)[0])
296
328
else:
297
329
message = "enabled"
298
self.using_timer(False)
299
self._text = "{0}{1}".format(base, message)
300
330
self._text = "%s%s" % (base, message)
331
301
332
if not urwid.supports_unicode():
302
333
self._text = self._text.encode("ascii", "replace")
303
334
textlist = [("normal", self._text)]
315
346
self.update_hook()
316
347
317
348
def update_timer(self):
318
"""called by gobject. Will indefinitely loop until
319
gobject.source_remove() on tag is called"""
349
"called by gobject"
320
350
self.update()
321
351
return True # Keep calling this
322
352
323
def delete(self, **kwargs):
353
def delete(self, *args, **kwargs):
324
354
if self._update_timer_callback_tag is not None:
325
355
gobject.source_remove(self._update_timer_callback_tag)
326
356
self._update_timer_callback_tag = None
329
359
self.match_objects = ()
330
360
if self.delete_hook is not None:
331
361
self.delete_hook(self)
332
return super(MandosClientWidget, self).delete(**kwargs)
362
return super(MandosClientWidget, self).delete(*args, **kwargs)
333
363
334
364
def render(self, maxcolrow, focus=False):
335
365
"""Render differently if we have focus.
377
407
else:
378
408
return key
379
409
380
def property_changed(self, property=None, **kwargs):
410
def property_changed(self, property=None, value=None,
411
*args, **kwargs):
381
412
"""Call self.update() if old value is not new value.
382
413
This overrides the method from MandosClientPropertyCache"""
383
property_name = str(property)
414
property_name = unicode(property)
384
415
old_value = self.properties.get(property_name)
385
416
super(MandosClientWidget, self).property_changed(
386
property=property, **kwargs)
417
property=property, value=value, *args, **kwargs)
387
418
if self.properties.get(property_name) != old_value:
388
419
self.update()
389
420
393
424
"down" key presses, thus not allowing any containing widgets to
394
425
use them as an excuse to shift focus away from this widget.
395
426
"""
396
def keypress(self, *args, **kwargs):
397
ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
427
def keypress(self, maxcolrow, key):
428
ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)
398
429
if ret in ("up", "down"):
399
430
return
400
431
return ret
413
444
("normal",
414
445
"default", "default", None),
415
446
("bold",
416
"bold", "default", "bold"),
447
"default", "default", "bold"),
417
448
("underline-blink",
418
"underline,blink", "default", "underline,blink"),
449
"default", "default", "underline"),
419
450
("standout",
420
"standout", "default", "standout"),
451
"default", "default", "standout"),
421
452
("bold-underline-blink",
422
"bold,underline,blink", "default", "bold,underline,blink"),
453
"default", "default", ("bold", "underline")),
423
454
("bold-standout",
424
"bold,standout", "default", "bold,standout"),
455
"default", "default", ("bold", "standout")),
425
456
("underline-blink-standout",
426
"underline,blink,standout", "default",
427
"underline,blink,standout"),
457
"default", "default", ("underline", "standout")),
428
458
("bold-underline-blink-standout",
429
"bold,underline,blink,standout", "default",
430
"bold,underline,blink,standout"),
459
"default", "default", ("bold", "underline",
460
"standout")),
431
461
))
432
462
433
463
if urwid.supports_unicode():
465
495
466
496
self.busname = domain + '.Mandos'
467
497
self.main_loop = gobject.MainLoop()
498
self.bus = dbus.SystemBus()
499
mandos_dbus_objc = self.bus.get_object(
500
self.busname, "/", follow_name_owner_changes=True)
501
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
502
dbus_interface
503
= server_interface)
504
try:
505
mandos_clients = (self.mandos_serv
506
.GetAllClientsWithProperties())
507
except dbus.exceptions.DBusException:
508
mandos_clients = dbus.Dictionary()
509
510
(self.mandos_serv
511
.connect_to_signal("ClientRemoved",
512
self.find_and_remove_client,
513
dbus_interface=server_interface,
514
byte_arrays=True))
515
(self.mandos_serv
516
.connect_to_signal("ClientAdded",
517
self.add_new_client,
518
dbus_interface=server_interface,
519
byte_arrays=True))
520
(self.mandos_serv
521
.connect_to_signal("ClientNotFound",
522
self.client_not_found,
523
dbus_interface=server_interface,
524
byte_arrays=True))
525
for path, client in mandos_clients.iteritems():
526
client_proxy_object = self.bus.get_object(self.busname,
527
path)
528
self.add_client(MandosClientWidget(server_proxy_object
529
=self.mandos_serv,
530
proxy_object
531
=client_proxy_object,
532
properties=client,
533
update_hook
534
=self.refresh,
535
delete_hook
536
=self.remove_client,
537
logger
538
=self.log_message),
539
path=path)
468
540
469
541
def client_not_found(self, fingerprint, address):
470
self.log_message("Client with address {0} and fingerprint"
471
" {1} could not be found"
472
.format(address, fingerprint))
542
self.log_message(("Client with address %s and fingerprint %s"
543
" could not be found" % (address,
544
fingerprint)))
473
545
474
546
def rebuild(self):
475
547
"""This rebuilds the User Interface.
485
557
self.divider)))
486
558
if self.log_visible:
487
559
self.uilist.append(self.logbox)
560
pass
488
561
self.topwidget = urwid.Pile(self.uilist)
489
562
490
563
def log_message(self, message):
491
"""Log message formatted with timestamp"""
492
564
timestamp = datetime.datetime.now().isoformat()
493
565
self.log_message_raw(timestamp + ": " + message)
494
566
507
579
self.log_visible = not self.log_visible
508
580
self.rebuild()
509
581
#self.log_message("Log visibility changed to: "
510
# + str(self.log_visible))
582
# + unicode(self.log_visible))
511
583
512
584
def change_log_display(self):
513
585
"""Change type of log display.
529
601
client = self.clients_dict[path]
530
602
except KeyError:
531
603
# not found?
532
self.log_message("Unknown client {0!r} ({1!r}) removed"
533
.format(name, path))
604
self.log_message("Unknown client %r (%r) removed", name,
605
path)
534
606
return
535
607
client.delete()
536
608
553
625
if path is None:
554
626
path = client.proxy.object_path
555
627
self.clients_dict[path] = client
556
self.clients.sort(key=lambda c: c.properties["Name"])
628
self.clients.sort(None, lambda c: c.properties["Name"])
557
629
self.refresh()
558
630
559
631
def remove_client(self, client, path=None):
561
633
if path is None:
562
634
path = client.proxy.object_path
563
635
del self.clients_dict[path]
636
if not self.clients_dict:
637
# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
638
# is completely emptied, we need to recreate it.
639
self.clients = urwid.SimpleListWalker([])
640
self.rebuild()
564
641
self.refresh()
565
642
566
643
def refresh(self):
570
647
571
648
def run(self):
572
649
"""Start the main loop and exit when it's done."""
573
self.bus = dbus.SystemBus()
574
mandos_dbus_objc = self.bus.get_object(
575
self.busname, "/", follow_name_owner_changes=True)
576
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
577
dbus_interface
578
= server_interface)
579
try:
580
mandos_clients = (self.mandos_serv
581
.GetAllClientsWithProperties())
582
if not mandos_clients:
583
self.log_message_raw(("bold", "Note: Server has no clients."))
584
except dbus.exceptions.DBusException:
585
self.log_message_raw(("bold", "Note: No Mandos server running."))
586
mandos_clients = dbus.Dictionary()
587
588
(self.mandos_serv
589
.connect_to_signal("ClientRemoved",
590
self.find_and_remove_client,
591
dbus_interface=server_interface,
592
byte_arrays=True))
593
(self.mandos_serv
594
.connect_to_signal("ClientAdded",
595
self.add_new_client,
596
dbus_interface=server_interface,
597
byte_arrays=True))
598
(self.mandos_serv
599
.connect_to_signal("ClientNotFound",
600
self.client_not_found,
601
dbus_interface=server_interface,
602
byte_arrays=True))
603
for path, client in mandos_clients.items():
604
client_proxy_object = self.bus.get_object(self.busname,
605
path)
606
self.add_client(MandosClientWidget(server_proxy_object
607
=self.mandos_serv,
608
proxy_object
609
=client_proxy_object,
610
properties=client,
611
update_hook
612
=self.refresh,
613
delete_hook
614
=self.remove_client,
615
logger
616
=self.log_message),
617
path=path)
618
619
650
self.refresh()
620
651
self._input_callback_tag = (gobject.io_add_watch
621
652
(sys.stdin.fileno(),
718
749
ui.run()
719
750
except KeyboardInterrupt:
720
751
ui.screen.stop()
721
except Exception as e:
722
ui.log_message(str(e))
752
except Exception, e:
753
ui.log_message(unicode(e))
723
754
ui.screen.stop()
724
755
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0