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 550
- compare with another revision
- download diff
- download tarball
- view history from revision 550
- Committer: Teddy Hogeborn
- Date: 2012-01-01 20:45:53 UTC
- Revision ID: teddy@recompile.se-20120101204553-f1zlty873gswtf5n
* README: Hint that the intro(8mandos) manual page is in the server
package.
package.
- files removed:
- debian/mandos-client.examples
- debian/upstream
- 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-2012 Teddy Hogeborn
7
# Copyright © 2009-2012 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
22
# Contact the authors at <mandos@recompile.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.major == 2:
52
str = unicode
53
54
46
locale.setlocale(locale.LC_ALL, '')
55
47
56
48
import logging
60
52
domain = 'se.recompile'
61
53
server_interface = domain + '.Mandos'
62
54
client_interface = domain + '.Mandos.Client'
63
version = "1.6.8"
55
version = "1.5.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)
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 {}'
165
.format(self.properties["Name"]), level=0)
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:
182
self.logger('Checker for client {} (command "{}")'
183
' succeeded'.format(self.properties["Name"],
184
command), level=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))
185
219
self.update()
186
220
return
187
221
# Checker failed
222
if not self.last_checker_failed:
223
self.last_checker_failed = True
224
self.using_timer(True)
188
225
if os.WIFEXITED(condition):
189
self.logger('Checker for client {} (command "{}") failed'
190
' with exit code {}'
191
.format(self.properties["Name"], command,
192
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)))
193
230
elif os.WIFSIGNALED(condition):
194
self.logger('Checker for client {} (command "{}") was'
195
' killed by signal {}'
196
.format(self.properties["Name"], command,
197
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)))
198
235
elif os.WCOREDUMP(condition):
199
self.logger('Checker for client {} (command "{}") dumped'
200
' core'.format(self.properties["Name"],
201
command))
236
self.logger('Checker for client %s (command "%s")'
237
' dumped core'
238
% (self.properties["Name"], command))
202
239
else:
203
self.logger('Checker for client {} completed'
204
' mysteriously'
205
.format(self.properties["Name"]))
240
self.logger('Checker for client %s completed'
241
' mysteriously')
206
242
self.update()
207
243
208
244
def checker_started(self, command):
209
"""Server signals that a checker started."""
210
self.logger('Client {} started checker "{}"'
211
.format(self.properties["Name"],
212
command), level=0)
245
"""Server signals that a checker started. This could be useful
246
to log in the future. """
247
#self.logger('Client %s started checker "%s"'
248
# % (self.properties["Name"], unicode(command)))
249
pass
213
250
214
251
def got_secret(self):
215
self.logger('Client {} received its secret'
216
.format(self.properties["Name"]))
252
self.last_checker_failed = False
253
self.logger('Client %s received its secret'
254
% self.properties["Name"])
217
255
218
256
def need_approval(self, timeout, default):
219
257
if not default:
220
message = 'Client {} needs approval within {} seconds'
258
message = 'Client %s needs approval within %s seconds'
221
259
else:
222
message = 'Client {} will get its secret in {} seconds'
223
self.logger(message.format(self.properties["Name"],
224
timeout/1000))
260
message = 'Client %s will get its secret in %s seconds'
261
self.logger(message
262
% (self.properties["Name"], timeout/1000))
263
self.using_timer(True)
225
264
226
265
def rejected(self, reason):
227
self.logger('Client {} was rejected; reason: {}'
228
.format(self.properties["Name"], reason))
266
self.logger('Client %s was rejected; reason: %s'
267
% (self.properties["Name"], reason))
229
268
230
269
def selectable(self):
231
270
"""Make this a "selectable" widget.
253
292
"bold-underline-blink":
254
293
"bold-underline-blink-standout",
255
294
}
256
295
257
296
# Rebuild focus and non-focus widgets using current properties
258
297
259
298
# Base part of a client. Name!
260
base = '{name}: '.format(name=self.properties["Name"])
299
base = ('%(name)s: '
300
% {"name": self.properties["Name"]})
261
301
if not self.properties["Enabled"]:
262
302
message = "DISABLED"
263
self.using_timer(False)
264
303
elif self.properties["ApprovalPending"]:
265
304
timeout = datetime.timedelta(milliseconds
266
305
= self.properties
268
307
last_approval_request = isoformat_to_datetime(
269
308
self.properties["LastApprovalRequest"])
270
309
if last_approval_request is not None:
271
timer = max(timeout - (datetime.datetime.utcnow()
272
- last_approval_request),
273
datetime.timedelta())
310
timer = timeout - (datetime.datetime.utcnow()
311
- last_approval_request)
274
312
else:
275
313
timer = datetime.timedelta()
276
314
if self.properties["ApprovedByDefault"]:
277
message = "Approval in {}. (d)eny?"
315
message = "Approval in %s. (d)eny?"
278
316
else:
279
message = "Denial in {}. (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
317
message = "Denial in %s. (a)pprove?"
318
message = message % unicode(timer).rsplit(".", 1)[0]
319
elif self.last_checker_failed:
320
# When checker has failed, print a timer until client expires
284
321
expires = self.properties["Expires"]
285
322
if expires == "":
286
323
timer = datetime.timedelta(0)
287
324
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())
325
expires = datetime.datetime.strptime(expires,
326
'%Y-%m-%dT%H:%M:%S.%f')
327
timer = expires - datetime.datetime.utcnow()
292
328
message = ('A checker has failed! Time until client'
293
' gets disabled: {}'
294
.format(str(timer).rsplit(".", 1)[0]))
295
self.using_timer(True)
329
' gets disabled: %s'
330
% unicode(timer).rsplit(".", 1)[0])
296
331
else:
297
332
message = "enabled"
298
self.using_timer(False)
299
self._text = "{}{}".format(base, message)
300
333
self._text = "%s%s" % (base, message)
334
301
335
if not urwid.supports_unicode():
302
336
self._text = self._text.encode("ascii", "replace")
303
337
textlist = [("normal", self._text)]
320
354
self.update()
321
355
return True # Keep calling this
322
356
323
def delete(self, **kwargs):
357
def delete(self, *args, **kwargs):
324
358
if self._update_timer_callback_tag is not None:
325
359
gobject.source_remove(self._update_timer_callback_tag)
326
360
self._update_timer_callback_tag = None
329
363
self.match_objects = ()
330
364
if self.delete_hook is not None:
331
365
self.delete_hook(self)
332
return super(MandosClientWidget, self).delete(**kwargs)
366
return super(MandosClientWidget, self).delete(*args, **kwargs)
333
367
334
368
def render(self, maxcolrow, focus=False):
335
369
"""Render differently if we have focus.
377
411
else:
378
412
return key
379
413
380
def property_changed(self, property=None, **kwargs):
414
def property_changed(self, property=None, value=None,
415
*args, **kwargs):
381
416
"""Call self.update() if old value is not new value.
382
417
This overrides the method from MandosClientPropertyCache"""
383
property_name = str(property)
418
property_name = unicode(property)
384
419
old_value = self.properties.get(property_name)
385
420
super(MandosClientWidget, self).property_changed(
386
property=property, **kwargs)
421
property=property, value=value, *args, **kwargs)
387
422
if self.properties.get(property_name) != old_value:
388
423
self.update()
389
424
393
428
"down" key presses, thus not allowing any containing widgets to
394
429
use them as an excuse to shift focus away from this widget.
395
430
"""
396
def keypress(self, *args, **kwargs):
397
ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
431
def keypress(self, maxcolrow, key):
432
ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)
398
433
if ret in ("up", "down"):
399
434
return
400
435
return ret
404
439
"""This is the entire user interface - the whole screen
405
440
with boxes, lists of client widgets, etc.
406
441
"""
407
def __init__(self, max_log_length=1000, log_level=1):
442
def __init__(self, max_log_length=1000):
408
443
DBusGMainLoop(set_as_default=True)
409
444
410
445
self.screen = urwid.curses_display.Screen()
413
448
("normal",
414
449
"default", "default", None),
415
450
("bold",
416
"bold", "default", "bold"),
451
"default", "default", "bold"),
417
452
("underline-blink",
418
"underline,blink", "default", "underline,blink"),
453
"default", "default", "underline"),
419
454
("standout",
420
"standout", "default", "standout"),
455
"default", "default", "standout"),
421
456
("bold-underline-blink",
422
"bold,underline,blink", "default", "bold,underline,blink"),
457
"default", "default", ("bold", "underline")),
423
458
("bold-standout",
424
"bold,standout", "default", "bold,standout"),
459
"default", "default", ("bold", "standout")),
425
460
("underline-blink-standout",
426
"underline,blink,standout", "default",
427
"underline,blink,standout"),
461
"default", "default", ("underline", "standout")),
428
462
("bold-underline-blink-standout",
429
"bold,underline,blink,standout", "default",
430
"bold,underline,blink,standout"),
463
"default", "default", ("bold", "underline",
464
"standout")),
431
465
))
432
466
433
467
if urwid.supports_unicode():
448
482
self.log = []
449
483
self.max_log_length = max_log_length
450
484
451
self.log_level = log_level
452
453
485
# We keep a reference to the log widget so we can remove it
454
486
# from the ListWalker without it getting destroyed
455
487
self.logbox = ConstrainedListBox(self.log)
469
501
self.main_loop = gobject.MainLoop()
470
502
471
503
def client_not_found(self, fingerprint, address):
472
self.log_message("Client with address {} and fingerprint {}"
473
" could not be found"
474
.format(address, fingerprint))
504
self.log_message(("Client with address %s and fingerprint %s"
505
" could not be found" % (address,
506
fingerprint)))
475
507
476
508
def rebuild(self):
477
509
"""This rebuilds the User Interface.
489
521
self.uilist.append(self.logbox)
490
522
self.topwidget = urwid.Pile(self.uilist)
491
523
492
def log_message(self, message, level=1):
493
"""Log message formatted with timestamp"""
494
if level < self.log_level:
495
return
524
def log_message(self, message):
496
525
timestamp = datetime.datetime.now().isoformat()
497
self.log_message_raw("{}: {}".format(timestamp, message),
498
level=level)
526
self.log_message_raw(timestamp + ": " + message)
499
527
500
def log_message_raw(self, markup, level=1):
528
def log_message_raw(self, markup):
501
529
"""Add a log message to the log buffer."""
502
if level < self.log_level:
503
return
504
530
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
505
531
if (self.max_log_length
506
532
and len(self.log) > self.max_log_length):
513
539
"""Toggle visibility of the log buffer."""
514
540
self.log_visible = not self.log_visible
515
541
self.rebuild()
516
self.log_message("Log visibility changed to: {}"
517
.format(self.log_visible), level=0)
542
#self.log_message("Log visibility changed to: "
543
# + unicode(self.log_visible))
518
544
519
545
def change_log_display(self):
520
546
"""Change type of log display.
525
551
self.log_wrap = "clip"
526
552
for textwidget in self.log:
527
553
textwidget.set_wrap_mode(self.log_wrap)
528
self.log_message("Wrap mode: {}".format(self.log_wrap),
529
level=0)
554
#self.log_message("Wrap mode: " + self.log_wrap)
530
555
531
556
def find_and_remove_client(self, path, name):
532
557
"""Find a client by its object path and remove it.
537
562
client = self.clients_dict[path]
538
563
except KeyError:
539
564
# not found?
540
self.log_message("Unknown client {!r} ({!r}) removed"
541
.format(name, path))
565
self.log_message("Unknown client %r (%r) removed", name,
566
path)
542
567
return
543
568
client.delete()
544
569
561
586
if path is None:
562
587
path = client.proxy.object_path
563
588
self.clients_dict[path] = client
564
self.clients.sort(key=lambda c: c.properties["Name"])
589
self.clients.sort(None, lambda c: c.properties["Name"])
565
590
self.refresh()
566
591
567
592
def remove_client(self, client, path=None):
569
594
if path is None:
570
595
path = client.proxy.object_path
571
596
del self.clients_dict[path]
597
if not self.clients_dict:
598
# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
599
# is completely emptied, we need to recreate it.
600
self.clients = urwid.SimpleListWalker([])
601
self.rebuild()
572
602
self.refresh()
573
603
574
604
def refresh(self):
587
617
try:
588
618
mandos_clients = (self.mandos_serv
589
619
.GetAllClientsWithProperties())
590
if not mandos_clients:
591
self.log_message_raw(("bold", "Note: Server has no clients."))
592
620
except dbus.exceptions.DBusException:
593
self.log_message_raw(("bold", "Note: No Mandos server running."))
594
621
mandos_clients = dbus.Dictionary()
595
622
596
623
(self.mandos_serv
608
635
self.client_not_found,
609
636
dbus_interface=server_interface,
610
637
byte_arrays=True))
611
for path, client in mandos_clients.items():
638
for path, client in mandos_clients.iteritems():
612
639
client_proxy_object = self.bus.get_object(self.busname,
613
640
path)
614
641
self.add_client(MandosClientWidget(server_proxy_object
623
650
logger
624
651
=self.log_message),
625
652
path=path)
626
653
627
654
self.refresh()
628
655
self._input_callback_tag = (gobject.io_add_watch
629
656
(sys.stdin.fileno(),
661
688
elif key == "window resize":
662
689
self.size = self.screen.get_cols_rows()
663
690
self.refresh()
664
elif key == "ctrl l":
665
self.screen.clear()
691
elif key == "\f": # Ctrl-L
666
692
self.refresh()
667
693
elif key == "l" or key == "D":
668
694
self.toggle_log_display()
680
706
"?: Help",
681
707
"l: Log window toggle",
682
708
"TAB: Switch window",
683
"w: Wrap (log lines)",
684
"v: Toggle verbose log",
685
))))
709
"w: Wrap (log)"))))
686
710
self.log_message_raw(("bold",
687
711
" "
688
712
.join(("Clients:",
701
725
else:
702
726
self.topwidget.set_focus(self.logbox)
703
727
self.refresh()
704
elif key == "v":
705
if self.log_level == 0:
706
self.log_level = 1
707
self.log_message("Verbose mode: Off")
708
else:
709
self.log_level = 0
710
self.log_message("Verbose mode: On")
711
728
#elif (key == "end" or key == "meta >" or key == "G"
712
729
# or key == ">"):
713
730
# pass # xxx end-of-buffer
736
753
ui.run()
737
754
except KeyboardInterrupt:
738
755
ui.screen.stop()
739
except Exception as e:
740
ui.log_message(str(e))
756
except Exception, e:
757
ui.log_message(unicode(e))
741
758
ui.screen.stop()
742
759
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0