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.186
- compare with another revision
- download diff
- download tarball
- view history from revision 24.1.186
- Committer: Björn Påhlsson
- Date: 2011-10-02 19:18:24 UTC
- mto: (237.7.53 trunk)
- mto: This revision was merged to the branch mainline in revision 286.
- Revision ID: belorn@fukt.bsnet.se-20111002191824-eweh4pvneeg3qzia
transitional stuff actually working
documented change to D-Bus API
documented change to D-Bus API
- 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
60
52
domain = 'se.recompile'
61
53
server_interface = domain + '.Mandos'
62
54
client_interface = domain + '.Mandos.Client'
63
version = "1.6.6"
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"]), 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 {0} (command "{1}")'
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 {0} (command "{1}")'
190
' failed with exit code {2}'
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 {0} (command "{1}") was'
195
' killed by signal {2}'
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 {0} (command "{1}")'
236
self.logger('Checker for client %s (command "%s")'
200
237
' dumped core'
201
.format(self.properties["Name"], command))
238
% (self.properties["Name"], command))
202
239
else:
203
self.logger('Checker for client {0} 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 {0} started checker "{1}"'
211
.format(self.properties["Name"],
212
command), level=0)
245
#self.logger('Client %s started checker "%s"'
246
# % (self.properties["Name"], unicode(command)))
247
pass
213
248
214
249
def got_secret(self):
215
self.logger('Client {0} received its secret'
216
.format(self.properties["Name"]))
250
self.last_checker_failed = False
251
self.logger('Client %s received its secret'
252
% self.properties["Name"])
217
253
218
254
def need_approval(self, timeout, default):
219
255
if not default:
220
message = 'Client {0} needs approval within {1} seconds'
256
message = 'Client %s needs approval within %s seconds'
221
257
else:
222
message = 'Client {0} will get its secret in {1} seconds'
223
self.logger(message.format(self.properties["Name"],
224
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)
225
262
226
263
def rejected(self, reason):
227
self.logger('Client {0} was rejected; reason: {1}'
228
.format(self.properties["Name"], reason))
264
self.logger('Client %s was rejected; reason: %s'
265
% (self.properties["Name"], reason))
229
266
230
267
def selectable(self):
231
268
"""Make this a "selectable" widget.
253
290
"bold-underline-blink":
254
291
"bold-underline-blink-standout",
255
292
}
256
293
257
294
# Rebuild focus and non-focus widgets using current properties
258
295
259
296
# Base part of a client. Name!
260
base = '{name}: '.format(name=self.properties["Name"])
297
base = ('%(name)s: '
298
% {"name": self.properties["Name"]})
261
299
if not self.properties["Enabled"]:
262
300
message = "DISABLED"
263
self.using_timer(False)
264
301
elif self.properties["ApprovalPending"]:
265
302
timeout = datetime.timedelta(milliseconds
266
303
= self.properties
268
305
last_approval_request = isoformat_to_datetime(
269
306
self.properties["LastApprovalRequest"])
270
307
if last_approval_request is not None:
271
timer = max(timeout - (datetime.datetime.utcnow()
272
- last_approval_request),
273
datetime.timedelta())
308
timer = timeout - (datetime.datetime.utcnow()
309
- last_approval_request)
274
310
else:
275
311
timer = datetime.timedelta()
276
312
if self.properties["ApprovedByDefault"]:
277
message = "Approval in {0}. (d)eny?"
313
message = "Approval in %s. (d)eny?"
278
314
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
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
284
319
expires = self.properties["Expires"]
285
320
if expires == "":
286
321
timer = datetime.timedelta(0)
287
322
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())
323
expires = datetime.datetime.strptime(expires,
324
'%Y-%m-%dT%H:%M:%S.%f')
325
timer = expires - datetime.datetime.utcnow()
292
326
message = ('A checker has failed! Time until client'
293
' gets disabled: {0}'
294
.format(str(timer).rsplit(".", 1)[0]))
295
self.using_timer(True)
327
' gets disabled: %s'
328
% unicode(timer).rsplit(".", 1)[0])
296
329
else:
297
330
message = "enabled"
298
self.using_timer(False)
299
self._text = "{0}{1}".format(base, message)
300
331
self._text = "%s%s" % (base, message)
332
301
333
if not urwid.supports_unicode():
302
334
self._text = self._text.encode("ascii", "replace")
303
335
textlist = [("normal", self._text)]
320
352
self.update()
321
353
return True # Keep calling this
322
354
323
def delete(self, **kwargs):
355
def delete(self, *args, **kwargs):
324
356
if self._update_timer_callback_tag is not None:
325
357
gobject.source_remove(self._update_timer_callback_tag)
326
358
self._update_timer_callback_tag = None
329
361
self.match_objects = ()
330
362
if self.delete_hook is not None:
331
363
self.delete_hook(self)
332
return super(MandosClientWidget, self).delete(**kwargs)
364
return super(MandosClientWidget, self).delete(*args, **kwargs)
333
365
334
366
def render(self, maxcolrow, focus=False):
335
367
"""Render differently if we have focus.
377
409
else:
378
410
return key
379
411
380
def property_changed(self, property=None, **kwargs):
412
def property_changed(self, property=None, value=None,
413
*args, **kwargs):
381
414
"""Call self.update() if old value is not new value.
382
415
This overrides the method from MandosClientPropertyCache"""
383
property_name = str(property)
416
property_name = unicode(property)
384
417
old_value = self.properties.get(property_name)
385
418
super(MandosClientWidget, self).property_changed(
386
property=property, **kwargs)
419
property=property, value=value, *args, **kwargs)
387
420
if self.properties.get(property_name) != old_value:
388
421
self.update()
389
422
393
426
"down" key presses, thus not allowing any containing widgets to
394
427
use them as an excuse to shift focus away from this widget.
395
428
"""
396
def keypress(self, *args, **kwargs):
397
ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
429
def keypress(self, maxcolrow, key):
430
ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)
398
431
if ret in ("up", "down"):
399
432
return
400
433
return ret
404
437
"""This is the entire user interface - the whole screen
405
438
with boxes, lists of client widgets, etc.
406
439
"""
407
def __init__(self, max_log_length=1000, log_level=1):
440
def __init__(self, max_log_length=1000):
408
441
DBusGMainLoop(set_as_default=True)
409
442
410
443
self.screen = urwid.curses_display.Screen()
413
446
("normal",
414
447
"default", "default", None),
415
448
("bold",
416
"bold", "default", "bold"),
449
"default", "default", "bold"),
417
450
("underline-blink",
418
"underline,blink", "default", "underline,blink"),
451
"default", "default", "underline"),
419
452
("standout",
420
"standout", "default", "standout"),
453
"default", "default", "standout"),
421
454
("bold-underline-blink",
422
"bold,underline,blink", "default", "bold,underline,blink"),
455
"default", "default", ("bold", "underline")),
423
456
("bold-standout",
424
"bold,standout", "default", "bold,standout"),
457
"default", "default", ("bold", "standout")),
425
458
("underline-blink-standout",
426
"underline,blink,standout", "default",
427
"underline,blink,standout"),
459
"default", "default", ("underline", "standout")),
428
460
("bold-underline-blink-standout",
429
"bold,underline,blink,standout", "default",
430
"bold,underline,blink,standout"),
461
"default", "default", ("bold", "underline",
462
"standout")),
431
463
))
432
464
433
465
if urwid.supports_unicode():
448
480
self.log = []
449
481
self.max_log_length = max_log_length
450
482
451
self.log_level = log_level
452
453
483
# We keep a reference to the log widget so we can remove it
454
484
# from the ListWalker without it getting destroyed
455
485
self.logbox = ConstrainedListBox(self.log)
467
497
468
498
self.busname = domain + '.Mandos'
469
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)
470
542
471
543
def client_not_found(self, fingerprint, address):
472
self.log_message("Client with address {0} and fingerprint"
473
" {1} could not be found"
474
.format(address, fingerprint))
544
self.log_message(("Client with address %s and fingerprint %s"
545
" could not be found" % (address,
546
fingerprint)))
475
547
476
548
def rebuild(self):
477
549
"""This rebuilds the User Interface.
487
559
self.divider)))
488
560
if self.log_visible:
489
561
self.uilist.append(self.logbox)
562
pass
490
563
self.topwidget = urwid.Pile(self.uilist)
491
564
492
def log_message(self, message, level=1):
493
"""Log message formatted with timestamp"""
494
if level < self.log_level:
495
return
565
def log_message(self, message):
496
566
timestamp = datetime.datetime.now().isoformat()
497
self.log_message_raw("{0}: {1}".format(timestamp, message),
498
level=level)
567
self.log_message_raw(timestamp + ": " + message)
499
568
500
def log_message_raw(self, markup, level=1):
569
def log_message_raw(self, markup):
501
570
"""Add a log message to the log buffer."""
502
if level < self.log_level:
503
return
504
571
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
505
572
if (self.max_log_length
506
573
and len(self.log) > self.max_log_length):
513
580
"""Toggle visibility of the log buffer."""
514
581
self.log_visible = not self.log_visible
515
582
self.rebuild()
516
self.log_message("Log visibility changed to: {0}"
517
.format(self.log_visible), level=0)
583
#self.log_message("Log visibility changed to: "
584
# + unicode(self.log_visible))
518
585
519
586
def change_log_display(self):
520
587
"""Change type of log display.
525
592
self.log_wrap = "clip"
526
593
for textwidget in self.log:
527
594
textwidget.set_wrap_mode(self.log_wrap)
528
self.log_message("Wrap mode: {0}".format(self.log_wrap),
529
level=0)
595
#self.log_message("Wrap mode: " + self.log_wrap)
530
596
531
597
def find_and_remove_client(self, path, name):
532
598
"""Find a client by its object path and remove it.
537
603
client = self.clients_dict[path]
538
604
except KeyError:
539
605
# not found?
540
self.log_message("Unknown client {0!r} ({1!r}) removed"
541
.format(name, path))
606
self.log_message("Unknown client %r (%r) removed", name,
607
path)
542
608
return
543
609
client.delete()
544
610
561
627
if path is None:
562
628
path = client.proxy.object_path
563
629
self.clients_dict[path] = client
564
self.clients.sort(key=lambda c: c.properties["Name"])
630
self.clients.sort(None, lambda c: c.properties["Name"])
565
631
self.refresh()
566
632
567
633
def remove_client(self, client, path=None):
569
635
if path is None:
570
636
path = client.proxy.object_path
571
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()
572
643
self.refresh()
573
644
574
645
def refresh(self):
578
649
579
650
def run(self):
580
651
"""Start the main loop and exit when it's done."""
581
self.bus = dbus.SystemBus()
582
mandos_dbus_objc = self.bus.get_object(
583
self.busname, "/", follow_name_owner_changes=True)
584
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
585
dbus_interface
586
= server_interface)
587
try:
588
mandos_clients = (self.mandos_serv
589
.GetAllClientsWithProperties())
590
if not mandos_clients:
591
self.log_message_raw(("bold", "Note: Server has no clients."))
592
except dbus.exceptions.DBusException:
593
self.log_message_raw(("bold", "Note: No Mandos server running."))
594
mandos_clients = dbus.Dictionary()
595
596
(self.mandos_serv
597
.connect_to_signal("ClientRemoved",
598
self.find_and_remove_client,
599
dbus_interface=server_interface,
600
byte_arrays=True))
601
(self.mandos_serv
602
.connect_to_signal("ClientAdded",
603
self.add_new_client,
604
dbus_interface=server_interface,
605
byte_arrays=True))
606
(self.mandos_serv
607
.connect_to_signal("ClientNotFound",
608
self.client_not_found,
609
dbus_interface=server_interface,
610
byte_arrays=True))
611
for path, client in mandos_clients.items():
612
client_proxy_object = self.bus.get_object(self.busname,
613
path)
614
self.add_client(MandosClientWidget(server_proxy_object
615
=self.mandos_serv,
616
proxy_object
617
=client_proxy_object,
618
properties=client,
619
update_hook
620
=self.refresh,
621
delete_hook
622
=self.remove_client,
623
logger
624
=self.log_message),
625
path=path)
626
627
652
self.refresh()
628
653
self._input_callback_tag = (gobject.io_add_watch
629
654
(sys.stdin.fileno(),
679
704
"?: Help",
680
705
"l: Log window toggle",
681
706
"TAB: Switch window",
682
"w: Wrap (log lines)",
683
"v: Toggle verbose log",
684
))))
707
"w: Wrap (log)"))))
685
708
self.log_message_raw(("bold",
686
709
" "
687
710
.join(("Clients:",
700
723
else:
701
724
self.topwidget.set_focus(self.logbox)
702
725
self.refresh()
703
elif key == "v":
704
if self.log_level == 0:
705
self.log_level = 1
706
self.log_message("Verbose mode: Off")
707
else:
708
self.log_level = 0
709
self.log_message("Verbose mode: On")
710
726
#elif (key == "end" or key == "meta >" or key == "G"
711
727
# or key == ">"):
712
728
# pass # xxx end-of-buffer
735
751
ui.run()
736
752
except KeyboardInterrupt:
737
753
ui.screen.stop()
738
except Exception as e:
739
ui.log_message(str(e))
754
except Exception, e:
755
ui.log_message(unicode(e))
740
756
ui.screen.stop()
741
757
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0