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 585
- compare with another revision
- download diff
- download tarball
- view history from revision 585
- Committer: Teddy Hogeborn
- Date: 2012-05-17 01:55:58 UTC
- Revision ID: teddy@recompile.se-20120517015558-5703p8nkquc2rhgd
* .bzrignore (statedir): Added.
added
removed
mandos-monitor
3
3
#
4
4
# Mandos Monitor - Control and monitor the Mandos server
5
5
#
6
# Copyright © 2009-2016 Teddy Hogeborn
7
# Copyright © 2009-2016 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
25
25
26
26
from __future__ import (division, absolute_import, print_function,
27
27
unicode_literals)
28
try:
29
from future_builtins import *
30
except ImportError:
31
pass
28
29
from future_builtins import *
32
30
33
31
import sys
34
32
import os
33
import signal
35
34
36
35
import datetime
37
36
39
38
import urwid
40
39
41
40
from dbus.mainloop.glib import DBusGMainLoop
42
try:
43
from gi.repository import GObject
44
except ImportError:
45
import gobject as GObject
41
import gobject
46
42
47
43
import dbus
48
44
45
import UserList
46
49
47
import locale
50
48
51
if sys.version_info.major == 2:
52
str = unicode
53
54
49
locale.setlocale(locale.LC_ALL, '')
55
50
56
51
import logging
60
55
domain = 'se.recompile'
61
56
server_interface = domain + '.Mandos'
62
57
client_interface = domain + '.Mandos.Client'
63
version = "1.7.5"
64
65
try:
66
dbus.OBJECT_MANAGER_IFACE
67
except AttributeError:
68
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
58
version = "1.5.3"
59
60
# Always run in monochrome mode
61
urwid.curses_display.curses.has_colors = lambda : False
62
63
# Urwid doesn't support blinking, but we want it. Since we have no
64
# use for underline on its own, we make underline also always blink.
65
urwid.curses_display.curses.A_UNDERLINE |= (
66
urwid.curses_display.curses.A_BLINK)
69
67
70
68
def isoformat_to_datetime(iso):
71
69
"Parse an ISO 8601 date string to a datetime.datetime()"
92
90
self.proxy = proxy_object # Mandos Client proxy object
93
91
self.properties = dict() if properties is None else properties
94
92
self.property_changed_match = (
95
self.proxy.connect_to_signal("PropertiesChanged",
96
self.properties_changed,
97
dbus.PROPERTIES_IFACE,
93
self.proxy.connect_to_signal("PropertyChanged",
94
self._property_changed,
95
client_interface,
98
96
byte_arrays=True))
99
97
100
98
if properties is None:
105
103
106
104
super(MandosClientPropertyCache, self).__init__(**kwargs)
107
105
108
def properties_changed(self, interface, properties, invalidated):
109
"""This is called whenever we get a PropertiesChanged signal
110
It updates the changed properties in the "properties" dict.
106
def _property_changed(self, property, value):
107
"""Helper which takes positional arguments"""
108
return self.property_changed(property=property, value=value)
109
110
def property_changed(self, property=None, value=None):
111
"""This is called whenever we get a PropertyChanged signal
112
It updates the changed property in the "properties" dict.
111
113
"""
112
114
# Update properties dict with new value
113
if interface == client_interface:
114
self.properties.update(properties)
115
self.properties[property] = value
115
116
116
117
def delete(self):
117
118
self.property_changed_match.remove()
163
164
self.rejected,
164
165
client_interface,
165
166
byte_arrays=True))
166
self.logger('Created client {}'
167
.format(self.properties["Name"]), level=0)
167
#self.logger('Created client {0}'
168
# .format(self.properties["Name"]))
168
169
169
170
def using_timer(self, flag):
170
171
"""Call this method with True or False when timer should be
172
173
"""
173
174
if flag and self._update_timer_callback_tag is None:
174
175
# Will update the shown timer value every second
175
self._update_timer_callback_tag = (GObject.timeout_add
176
self._update_timer_callback_tag = (gobject.timeout_add
176
177
(1000,
177
178
self.update_timer))
178
179
elif not (flag or self._update_timer_callback_tag is None):
179
GObject.source_remove(self._update_timer_callback_tag)
180
gobject.source_remove(self._update_timer_callback_tag)
180
181
self._update_timer_callback_tag = None
181
182
182
183
def checker_completed(self, exitstatus, condition, command):
183
184
if exitstatus == 0:
184
self.logger('Checker for client {} (command "{}")'
185
' succeeded'.format(self.properties["Name"],
186
command), level=0)
187
185
self.update()
188
186
return
189
187
# Checker failed
190
188
if os.WIFEXITED(condition):
191
self.logger('Checker for client {} (command "{}") failed'
192
' with exit code {}'
189
self.logger('Checker for client {0} (command "{1}")'
190
' failed with exit code {2}'
193
191
.format(self.properties["Name"], command,
194
192
os.WEXITSTATUS(condition)))
195
193
elif os.WIFSIGNALED(condition):
196
self.logger('Checker for client {} (command "{}") was'
197
' killed by signal {}'
194
self.logger('Checker for client {0} (command "{1}") was'
195
' killed by signal {2}'
198
196
.format(self.properties["Name"], command,
199
197
os.WTERMSIG(condition)))
198
elif os.WCOREDUMP(condition):
199
self.logger('Checker for client {0} (command "{1}")'
200
' dumped core'
201
.format(self.properties["Name"], command))
202
else:
203
self.logger('Checker for client {0} completed'
204
' mysteriously'
205
.format(self.properties["Name"]))
200
206
self.update()
201
207
202
208
def checker_started(self, command):
203
"""Server signals that a checker started."""
204
self.logger('Client {} started checker "{}"'
205
.format(self.properties["Name"],
206
command), level=0)
209
"""Server signals that a checker started. This could be useful
210
to log in the future. """
211
#self.logger('Client {0} started checker "{1}"'
212
# .format(self.properties["Name"],
213
# unicode(command)))
214
pass
207
215
208
216
def got_secret(self):
209
self.logger('Client {} received its secret'
217
self.logger('Client {0} received its secret'
210
218
.format(self.properties["Name"]))
211
219
212
220
def need_approval(self, timeout, default):
213
221
if not default:
214
message = 'Client {} needs approval within {} seconds'
222
message = 'Client {0} needs approval within {1} seconds'
215
223
else:
216
message = 'Client {} will get its secret in {} seconds'
224
message = 'Client {0} will get its secret in {1} seconds'
217
225
self.logger(message.format(self.properties["Name"],
218
226
timeout/1000))
219
227
220
228
def rejected(self, reason):
221
self.logger('Client {} was rejected; reason: {}'
229
self.logger('Client {0} was rejected; reason: {1}'
222
230
.format(self.properties["Name"], reason))
223
231
224
232
def selectable(self):
268
276
else:
269
277
timer = datetime.timedelta()
270
278
if self.properties["ApprovedByDefault"]:
271
message = "Approval in {}. (d)eny?"
279
message = "Approval in {0}. (d)eny?"
272
280
else:
273
message = "Denial in {}. (a)pprove?"
274
message = message.format(str(timer).rsplit(".", 1)[0])
281
message = "Denial in {0}. (a)pprove?"
282
message = message.format(unicode(timer).rsplit(".", 1)[0])
275
283
self.using_timer(True)
276
284
elif self.properties["LastCheckerStatus"] != 0:
277
285
# When checker has failed, show timer until client expires
284
292
timer = max(expires - datetime.datetime.utcnow(),
285
293
datetime.timedelta())
286
294
message = ('A checker has failed! Time until client'
287
' gets disabled: {}'
288
.format(str(timer).rsplit(".", 1)[0]))
295
' gets disabled: {0}'
296
.format(unicode(timer).rsplit(".", 1)[0]))
289
297
self.using_timer(True)
290
298
else:
291
299
message = "enabled"
292
300
self.using_timer(False)
293
self._text = "{}{}".format(base, message)
301
self._text = "{0}{1}".format(base, message)
294
302
295
303
if not urwid.supports_unicode():
296
304
self._text = self._text.encode("ascii", "replace")
309
317
self.update_hook()
310
318
311
319
def update_timer(self):
312
"""called by GObject. Will indefinitely loop until
313
GObject.source_remove() on tag is called"""
320
"""called by gobject. Will indefinitely loop until
321
gobject.source_remove() on tag is called"""
314
322
self.update()
315
323
return True # Keep calling this
316
324
317
325
def delete(self, **kwargs):
318
326
if self._update_timer_callback_tag is not None:
319
GObject.source_remove(self._update_timer_callback_tag)
327
gobject.source_remove(self._update_timer_callback_tag)
320
328
self._update_timer_callback_tag = None
321
329
for match in self.match_objects:
322
330
match.remove()
335
343
"""Handle keys.
336
344
This overrides the method from urwid.FlowWidget"""
337
345
if key == "+":
338
self.proxy.Set(client_interface, "Enabled",
339
dbus.Boolean(True), ignore_reply = True,
340
dbus_interface = dbus.PROPERTIES_IFACE)
346
self.proxy.Enable(dbus_interface = client_interface,
347
ignore_reply=True)
341
348
elif key == "-":
342
self.proxy.Set(client_interface, "Enabled", False,
343
ignore_reply = True,
344
dbus_interface = dbus.PROPERTIES_IFACE)
349
self.proxy.Disable(dbus_interface = client_interface,
350
ignore_reply=True)
345
351
elif key == "a":
346
352
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
347
353
dbus_interface = client_interface,
355
361
.object_path,
356
362
ignore_reply=True)
357
363
elif key == "s":
358
self.proxy.Set(client_interface, "CheckerRunning",
359
dbus.Boolean(True), ignore_reply = True,
360
dbus_interface = dbus.PROPERTIES_IFACE)
364
self.proxy.StartChecker(dbus_interface = client_interface,
365
ignore_reply=True)
361
366
elif key == "S":
362
self.proxy.Set(client_interface, "CheckerRunning",
363
dbus.Boolean(False), ignore_reply = True,
364
dbus_interface = dbus.PROPERTIES_IFACE)
367
self.proxy.StopChecker(dbus_interface = client_interface,
368
ignore_reply=True)
365
369
elif key == "C":
366
370
self.proxy.CheckedOK(dbus_interface = client_interface,
367
371
ignore_reply=True)
375
379
else:
376
380
return key
377
381
378
def properties_changed(self, interface, properties, invalidated):
379
"""Call self.update() if any properties changed.
382
def property_changed(self, property=None, **kwargs):
383
"""Call self.update() if old value is not new value.
380
384
This overrides the method from MandosClientPropertyCache"""
381
old_values = { key: self.properties.get(key)
382
for key in properties.keys() }
383
super(MandosClientWidget, self).properties_changed(
384
interface, properties, invalidated)
385
if any(old_values[key] != self.properties.get(key)
386
for key in old_values):
385
property_name = unicode(property)
386
old_value = self.properties.get(property_name)
387
super(MandosClientWidget, self).property_changed(
388
property=property, **kwargs)
389
if self.properties.get(property_name) != old_value:
387
390
self.update()
388
391
389
392
403
406
"""This is the entire user interface - the whole screen
404
407
with boxes, lists of client widgets, etc.
405
408
"""
406
def __init__(self, max_log_length=1000, log_level=1):
409
def __init__(self, max_log_length=1000):
407
410
DBusGMainLoop(set_as_default=True)
408
411
409
412
self.screen = urwid.curses_display.Screen()
412
415
("normal",
413
416
"default", "default", None),
414
417
("bold",
415
"bold", "default", "bold"),
418
"default", "default", "bold"),
416
419
("underline-blink",
417
"underline,blink", "default", "underline,blink"),
420
"default", "default", "underline"),
418
421
("standout",
419
"standout", "default", "standout"),
422
"default", "default", "standout"),
420
423
("bold-underline-blink",
421
"bold,underline,blink", "default", "bold,underline,blink"),
424
"default", "default", ("bold", "underline")),
422
425
("bold-standout",
423
"bold,standout", "default", "bold,standout"),
426
"default", "default", ("bold", "standout")),
424
427
("underline-blink-standout",
425
"underline,blink,standout", "default",
426
"underline,blink,standout"),
428
"default", "default", ("underline", "standout")),
427
429
("bold-underline-blink-standout",
428
"bold,underline,blink,standout", "default",
429
"bold,underline,blink,standout"),
430
"default", "default", ("bold", "underline",
431
"standout")),
430
432
))
431
433
432
434
if urwid.supports_unicode():
447
449
self.log = []
448
450
self.max_log_length = max_log_length
449
451
450
self.log_level = log_level
451
452
452
# We keep a reference to the log widget so we can remove it
453
453
# from the ListWalker without it getting destroyed
454
454
self.logbox = ConstrainedListBox(self.log)
465
465
"q: Quit ?: Help"))
466
466
467
467
self.busname = domain + '.Mandos'
468
self.main_loop = GObject.MainLoop()
468
self.main_loop = gobject.MainLoop()
469
469
470
470
def client_not_found(self, fingerprint, address):
471
self.log_message("Client with address {} and fingerprint {}"
472
" could not be found"
471
self.log_message("Client with address {0} and fingerprint"
472
" {1} could not be found"
473
473
.format(address, fingerprint))
474
474
475
475
def rebuild(self):
488
488
self.uilist.append(self.logbox)
489
489
self.topwidget = urwid.Pile(self.uilist)
490
490
491
def log_message(self, message, level=1):
492
"""Log message formatted with timestamp"""
493
if level < self.log_level:
494
return
491
def log_message(self, message):
495
492
timestamp = datetime.datetime.now().isoformat()
496
self.log_message_raw("{}: {}".format(timestamp, message),
497
level=level)
493
self.log_message_raw(timestamp + ": " + message)
498
494
499
def log_message_raw(self, markup, level=1):
495
def log_message_raw(self, markup):
500
496
"""Add a log message to the log buffer."""
501
if level < self.log_level:
502
return
503
497
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
504
498
if (self.max_log_length
505
499
and len(self.log) > self.max_log_length):
512
506
"""Toggle visibility of the log buffer."""
513
507
self.log_visible = not self.log_visible
514
508
self.rebuild()
515
self.log_message("Log visibility changed to: {}"
516
.format(self.log_visible), level=0)
509
#self.log_message("Log visibility changed to: "
510
# + unicode(self.log_visible))
517
511
518
512
def change_log_display(self):
519
513
"""Change type of log display.
524
518
self.log_wrap = "clip"
525
519
for textwidget in self.log:
526
520
textwidget.set_wrap_mode(self.log_wrap)
527
self.log_message("Wrap mode: {}".format(self.log_wrap),
528
level=0)
521
#self.log_message("Wrap mode: " + self.log_wrap)
529
522
530
def find_and_remove_client(self, path, interfaces):
523
def find_and_remove_client(self, path, name):
531
524
"""Find a client by its object path and remove it.
532
525
533
This is connected to the InterfacesRemoved signal from the
526
This is connected to the ClientRemoved signal from the
534
527
Mandos server object."""
535
if client_interface not in interfaces:
536
# Not a Mandos client object; ignore
537
return
538
528
try:
539
529
client = self.clients_dict[path]
540
530
except KeyError:
541
531
# not found?
542
self.log_message("Unknown client {!r} removed"
543
.format(path))
532
self.log_message("Unknown client {0!r} ({1!r}) removed"
533
.format(name, path))
544
534
return
545
535
client.delete()
546
536
547
def add_new_client(self, path, ifs_and_props):
548
"""Find a client by its object path and remove it.
549
550
This is connected to the InterfacesAdded signal from the
551
Mandos server object.
552
"""
553
if client_interface not in ifs_and_props:
554
# Not a Mandos client object; ignore
555
return
537
def add_new_client(self, path):
556
538
client_proxy_object = self.bus.get_object(self.busname, path)
557
539
self.add_client(MandosClientWidget(server_proxy_object
558
540
=self.mandos_serv,
563
545
delete_hook
564
546
=self.remove_client,
565
547
logger
566
=self.log_message,
567
properties
568
= dict(ifs_and_props[
569
client_interface])),
548
=self.log_message),
570
549
path=path)
571
550
572
551
def add_client(self, client, path=None):
574
553
if path is None:
575
554
path = client.proxy.object_path
576
555
self.clients_dict[path] = client
577
self.clients.sort(key=lambda c: c.properties["Name"])
556
self.clients.sort(None, lambda c: c.properties["Name"])
578
557
self.refresh()
579
558
580
559
def remove_client(self, client, path=None):
582
561
if path is None:
583
562
path = client.proxy.object_path
584
563
del self.clients_dict[path]
564
if not self.clients_dict:
565
# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
566
# is completely emptied, we need to recreate it.
567
self.clients = urwid.SimpleListWalker([])
568
self.rebuild()
585
569
self.refresh()
586
570
587
571
def refresh(self):
600
584
try:
601
585
mandos_clients = (self.mandos_serv
602
586
.GetAllClientsWithProperties())
603
if not mandos_clients:
604
self.log_message_raw(("bold", "Note: Server has no clients."))
605
587
except dbus.exceptions.DBusException:
606
self.log_message_raw(("bold", "Note: No Mandos server running."))
607
588
mandos_clients = dbus.Dictionary()
608
589
609
590
(self.mandos_serv
610
.connect_to_signal("InterfacesRemoved",
591
.connect_to_signal("ClientRemoved",
611
592
self.find_and_remove_client,
612
dbus_interface
613
= dbus.OBJECT_MANAGER_IFACE,
593
dbus_interface=server_interface,
614
594
byte_arrays=True))
615
595
(self.mandos_serv
616
.connect_to_signal("InterfacesAdded",
596
.connect_to_signal("ClientAdded",
617
597
self.add_new_client,
618
dbus_interface
619
= dbus.OBJECT_MANAGER_IFACE,
598
dbus_interface=server_interface,
620
599
byte_arrays=True))
621
600
(self.mandos_serv
622
601
.connect_to_signal("ClientNotFound",
623
602
self.client_not_found,
624
603
dbus_interface=server_interface,
625
604
byte_arrays=True))
626
for path, client in mandos_clients.items():
605
for path, client in mandos_clients.iteritems():
627
606
client_proxy_object = self.bus.get_object(self.busname,
628
607
path)
629
608
self.add_client(MandosClientWidget(server_proxy_object
640
619
path=path)
641
620
642
621
self.refresh()
643
self._input_callback_tag = (GObject.io_add_watch
622
self._input_callback_tag = (gobject.io_add_watch
644
623
(sys.stdin.fileno(),
645
GObject.IO_IN,
624
gobject.IO_IN,
646
625
self.process_input))
647
626
self.main_loop.run()
648
627
# Main loop has finished, we should close everything now
649
GObject.source_remove(self._input_callback_tag)
628
gobject.source_remove(self._input_callback_tag)
650
629
self.screen.stop()
651
630
652
631
def stop(self):
676
655
elif key == "window resize":
677
656
self.size = self.screen.get_cols_rows()
678
657
self.refresh()
679
elif key == "ctrl l":
680
self.screen.clear()
658
elif key == "\f": # Ctrl-L
681
659
self.refresh()
682
660
elif key == "l" or key == "D":
683
661
self.toggle_log_display()
695
673
"?: Help",
696
674
"l: Log window toggle",
697
675
"TAB: Switch window",
698
"w: Wrap (log lines)",
699
"v: Toggle verbose log",
700
))))
676
"w: Wrap (log)"))))
701
677
self.log_message_raw(("bold",
702
678
" "
703
679
.join(("Clients:",
716
692
else:
717
693
self.topwidget.set_focus(self.logbox)
718
694
self.refresh()
719
elif key == "v":
720
if self.log_level == 0:
721
self.log_level = 1
722
self.log_message("Verbose mode: Off")
723
else:
724
self.log_level = 0
725
self.log_message("Verbose mode: On")
726
695
#elif (key == "end" or key == "meta >" or key == "G"
727
696
# or key == ">"):
728
697
# pass # xxx end-of-buffer
751
720
ui.run()
752
721
except KeyboardInterrupt:
753
722
ui.screen.stop()
754
except Exception as e:
755
ui.log_message(str(e))
723
except Exception, e:
724
ui.log_message(unicode(e))
756
725
ui.screen.stop()
757
726
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0