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