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.30
- compare with another revision
- download diff
- download tarball
- view history from revision 237.4.30
- Committer: Teddy Hogeborn
- Date: 2012-05-12 19:56:55 UTC
- mfrom: (237.6.2 nmu)
- mto: (237.4.31 release)
- mto: This revision was merged to the branch mainline in revision 586.
- Revision ID: teddy@recompile.se-20120512195655-cy7w8ts3l9p22l3z
Tags: version-1.5.3-1.2
Merge NMU change
- files removed:
- debian/mandos-client.examples
- debian/upstream
- plugin-helpers
- files modified:
- .bzrignore
added
removed
mandos-monitor
3
3
#
4
4
# Mandos Monitor - Control and monitor the Mandos server
5
5
#
6
# Copyright © 2009-2015 Teddy Hogeborn
7
# Copyright © 2009-2015 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.9"
55
version = "1.5.3"
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
self.proxy.connect_to_signal("PropertiesChanged",
91
self.properties_changed,
92
dbus.PROPERTIES_IFACE,
91
self.proxy.connect_to_signal("PropertyChanged",
92
self.property_changed,
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)
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)
102
103
103
def properties_changed(self, interface, properties, invalidated):
104
"""This is called whenever we get a PropertiesChanged signal
105
It updates the changed properties in the "properties" dict.
104
def property_changed(self, property=None, value=None):
105
"""This is called whenever we get a PropertyChanged signal
106
It updates the changed property in the "properties" dict.
106
107
"""
107
108
# Update properties dict with new value
108
self.properties.update(properties)
109
self.properties[property] = value
109
110
110
def delete(self):
111
def delete(self, *args, **kwargs):
111
112
self.property_changed_match.remove()
113
super(MandosClientPropertyCache, self).__init__(
114
*args, **kwargs)
112
115
113
116
114
117
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
116
119
"""
117
120
118
121
def __init__(self, server_proxy_object=None, update_hook=None,
119
delete_hook=None, logger=None, **kwargs):
122
delete_hook=None, logger=None, *args, **kwargs):
120
123
# Called on update
121
124
self.update_hook = update_hook
122
125
# Called on delete
127
130
self.logger = logger
128
131
129
132
self._update_timer_callback_tag = None
133
self._update_timer_callback_lock = 0
130
134
131
135
# The widget shown normally
132
136
self._text_widget = urwid.Text("")
133
137
# The widget shown when we have focus
134
138
self._focus_text_widget = urwid.Text("")
135
super(MandosClientWidget, self).__init__(**kwargs)
139
super(MandosClientWidget, self).__init__(
140
update_hook=update_hook, delete_hook=delete_hook,
141
*args, **kwargs)
136
142
self.update()
137
143
self.opened = False
138
144
145
last_checked_ok = isoformat_to_datetime(self.properties
146
["LastCheckedOK"])
147
148
if self.properties ["LastCheckerStatus"] != 0:
149
self.using_timer(True)
150
151
if self.need_approval:
152
self.using_timer(True)
153
139
154
self.match_objects = (
140
155
self.proxy.connect_to_signal("CheckerCompleted",
141
156
self.checker_completed,
157
172
self.rejected,
158
173
client_interface,
159
174
byte_arrays=True))
160
self.logger('Created client {}'
161
.format(self.properties["Name"]), level=0)
175
#self.logger('Created client %s' % (self.properties["Name"]))
176
177
def property_changed(self, property=None, value=None):
178
super(self, MandosClientWidget).property_changed(property,
179
value)
180
if property == "ApprovalPending":
181
using_timer(bool(value))
182
if property == "LastCheckerStatus":
183
using_timer(value != 0)
184
#self.logger('Checker for client %s (command "%s")'
185
# ' was successful'
186
# % (self.properties["Name"], command))
162
187
163
188
def using_timer(self, flag):
164
189
"""Call this method with True or False when timer should be
165
190
activated or deactivated.
166
191
"""
167
if flag and self._update_timer_callback_tag is None:
192
old = self._update_timer_callback_lock
193
if flag:
194
self._update_timer_callback_lock += 1
195
else:
196
self._update_timer_callback_lock -= 1
197
if old == 0 and self._update_timer_callback_lock:
168
198
# Will update the shown timer value every second
169
199
self._update_timer_callback_tag = (gobject.timeout_add
170
200
(1000,
171
201
self.update_timer))
172
elif not (flag or self._update_timer_callback_tag is None):
202
elif old and self._update_timer_callback_lock == 0:
173
203
gobject.source_remove(self._update_timer_callback_tag)
174
204
self._update_timer_callback_tag = None
175
205
176
def checker_completed(self, exitstatus, signal, command):
206
def checker_completed(self, exitstatus, condition, command):
177
207
if exitstatus == 0:
178
self.logger('Checker for client {} (command "{}")'
179
' succeeded'.format(self.properties["Name"],
180
command), level=0)
181
208
self.update()
182
209
return
183
210
# Checker failed
184
if exitstatus >= 0:
185
self.logger('Checker for client {} (command "{}") failed'
186
' with exit code {}'
187
.format(self.properties["Name"], command,
188
exitstatus))
189
elif signal != 0:
190
self.logger('Checker for client {} (command "{}") was'
191
' killed by signal {}'
192
.format(self.properties["Name"], command,
193
signal))
211
if os.WIFEXITED(condition):
212
self.logger('Checker for client %s (command "%s")'
213
' failed with exit code %s'
214
% (self.properties["Name"], command,
215
os.WEXITSTATUS(condition)))
216
elif os.WIFSIGNALED(condition):
217
self.logger('Checker for client %s (command "%s")'
218
' was killed by signal %s'
219
% (self.properties["Name"], command,
220
os.WTERMSIG(condition)))
221
elif os.WCOREDUMP(condition):
222
self.logger('Checker for client %s (command "%s")'
223
' dumped core'
224
% (self.properties["Name"], command))
194
225
else:
195
self.logger('Checker for client {} completed'
196
' mysteriously'
197
.format(self.properties["Name"]))
226
self.logger('Checker for client %s completed'
227
' mysteriously')
198
228
self.update()
199
229
200
230
def checker_started(self, command):
201
"""Server signals that a checker started."""
202
self.logger('Client {} started checker "{}"'
203
.format(self.properties["Name"],
204
command), level=0)
231
"""Server signals that a checker started. This could be useful
232
to log in the future. """
233
#self.logger('Client %s started checker "%s"'
234
# % (self.properties["Name"], unicode(command)))
235
pass
205
236
206
237
def got_secret(self):
207
self.logger('Client {} received its secret'
208
.format(self.properties["Name"]))
238
self.logger('Client %s received its secret'
239
% self.properties["Name"])
209
240
210
241
def need_approval(self, timeout, default):
211
242
if not default:
212
message = 'Client {} needs approval within {} seconds'
243
message = 'Client %s needs approval within %s seconds'
213
244
else:
214
message = 'Client {} will get its secret in {} seconds'
215
self.logger(message.format(self.properties["Name"],
216
timeout/1000))
245
message = 'Client %s will get its secret in %s seconds'
246
self.logger(message
247
% (self.properties["Name"], timeout/1000))
248
self.using_timer(True)
217
249
218
250
def rejected(self, reason):
219
self.logger('Client {} was rejected; reason: {}'
220
.format(self.properties["Name"], reason))
251
self.logger('Client %s was rejected; reason: %s'
252
% (self.properties["Name"], reason))
221
253
222
254
def selectable(self):
223
255
"""Make this a "selectable" widget.
245
277
"bold-underline-blink":
246
278
"bold-underline-blink-standout",
247
279
}
248
280
249
281
# Rebuild focus and non-focus widgets using current properties
250
282
251
283
# Base part of a client. Name!
252
base = '{name}: '.format(name=self.properties["Name"])
284
base = ('%(name)s: '
285
% {"name": self.properties["Name"]})
253
286
if not self.properties["Enabled"]:
254
287
message = "DISABLED"
255
self.using_timer(False)
256
288
elif self.properties["ApprovalPending"]:
257
289
timeout = datetime.timedelta(milliseconds
258
290
= self.properties
260
292
last_approval_request = isoformat_to_datetime(
261
293
self.properties["LastApprovalRequest"])
262
294
if last_approval_request is not None:
263
timer = max(timeout - (datetime.datetime.utcnow()
264
- last_approval_request),
265
datetime.timedelta())
295
timer = timeout - (datetime.datetime.utcnow()
296
- last_approval_request)
266
297
else:
267
298
timer = datetime.timedelta()
268
299
if self.properties["ApprovedByDefault"]:
269
message = "Approval in {}. (d)eny?"
300
message = "Approval in %s. (d)eny?"
270
301
else:
271
message = "Denial in {}. (a)pprove?"
272
message = message.format(str(timer).rsplit(".", 1)[0])
273
self.using_timer(True)
302
message = "Denial in %s. (a)pprove?"
303
message = message % unicode(timer).rsplit(".", 1)[0]
274
304
elif self.properties["LastCheckerStatus"] != 0:
275
# When checker has failed, show timer until client expires
305
# When checker has failed, print a timer until client expires
276
306
expires = self.properties["Expires"]
277
307
if expires == "":
278
308
timer = datetime.timedelta(0)
279
309
else:
280
expires = (datetime.datetime.strptime
281
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
282
timer = max(expires - datetime.datetime.utcnow(),
283
datetime.timedelta())
310
expires = datetime.datetime.strptime(expires,
311
'%Y-%m-%dT%H:%M:%S.%f')
312
timer = expires - datetime.datetime.utcnow()
284
313
message = ('A checker has failed! Time until client'
285
' gets disabled: {}'
286
.format(str(timer).rsplit(".", 1)[0]))
287
self.using_timer(True)
314
' gets disabled: %s'
315
% unicode(timer).rsplit(".", 1)[0])
288
316
else:
289
317
message = "enabled"
290
self.using_timer(False)
291
self._text = "{}{}".format(base, message)
292
318
self._text = "%s%s" % (base, message)
319
293
320
if not urwid.supports_unicode():
294
321
self._text = self._text.encode("ascii", "replace")
295
322
textlist = [("normal", self._text)]
312
339
self.update()
313
340
return True # Keep calling this
314
341
315
def delete(self, **kwargs):
342
def delete(self, *args, **kwargs):
316
343
if self._update_timer_callback_tag is not None:
317
344
gobject.source_remove(self._update_timer_callback_tag)
318
345
self._update_timer_callback_tag = None
321
348
self.match_objects = ()
322
349
if self.delete_hook is not None:
323
350
self.delete_hook(self)
324
return super(MandosClientWidget, self).delete(**kwargs)
351
return super(MandosClientWidget, self).delete(*args, **kwargs)
325
352
326
353
def render(self, maxcolrow, focus=False):
327
354
"""Render differently if we have focus.
333
360
"""Handle keys.
334
361
This overrides the method from urwid.FlowWidget"""
335
362
if key == "+":
336
self.proxy.Set(client_interface, "Enabled",
337
dbus.Boolean(True), ignore_reply = True,
338
dbus_interface = dbus.PROPERTIES_IFACE)
363
self.proxy.Enable(dbus_interface = client_interface,
364
ignore_reply=True)
339
365
elif key == "-":
340
self.proxy.Set(client_interface, "Enabled", False,
341
ignore_reply = True,
342
dbus_interface = dbus.PROPERTIES_IFACE)
366
self.proxy.Disable(dbus_interface = client_interface,
367
ignore_reply=True)
343
368
elif key == "a":
344
369
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
345
370
dbus_interface = client_interface,
353
378
.object_path,
354
379
ignore_reply=True)
355
380
elif key == "s":
356
self.proxy.Set(client_interface, "CheckerRunning",
357
dbus.Boolean(True), ignore_reply = True,
358
dbus_interface = dbus.PROPERTIES_IFACE)
381
self.proxy.StartChecker(dbus_interface = client_interface,
382
ignore_reply=True)
359
383
elif key == "S":
360
self.proxy.Set(client_interface, "CheckerRunning",
361
dbus.Boolean(False), ignore_reply = True,
362
dbus_interface = dbus.PROPERTIES_IFACE)
384
self.proxy.StopChecker(dbus_interface = client_interface,
385
ignore_reply=True)
363
386
elif key == "C":
364
387
self.proxy.CheckedOK(dbus_interface = client_interface,
365
388
ignore_reply=True)
373
396
else:
374
397
return key
375
398
376
def properties_changed(self, interface, properties, invalidated):
377
"""Call self.update() if any properties changed.
399
def property_changed(self, property=None, value=None,
400
*args, **kwargs):
401
"""Call self.update() if old value is not new value.
378
402
This overrides the method from MandosClientPropertyCache"""
379
old_values = { key: self.properties.get(key)
380
for key in properties.keys() }
381
super(MandosClientWidget, self).properties_changed(
382
interface, properties, invalidated)
383
if any(old_values[key] != self.properties.get(key)
384
for key in old_values):
403
property_name = unicode(property)
404
old_value = self.properties.get(property_name)
405
super(MandosClientWidget, self).property_changed(
406
property=property, value=value, *args, **kwargs)
407
if self.properties.get(property_name) != old_value:
385
408
self.update()
386
409
387
410
390
413
"down" key presses, thus not allowing any containing widgets to
391
414
use them as an excuse to shift focus away from this widget.
392
415
"""
393
def keypress(self, *args, **kwargs):
394
ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
416
def keypress(self, maxcolrow, key):
417
ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)
395
418
if ret in ("up", "down"):
396
419
return
397
420
return ret
401
424
"""This is the entire user interface - the whole screen
402
425
with boxes, lists of client widgets, etc.
403
426
"""
404
def __init__(self, max_log_length=1000, log_level=1):
427
def __init__(self, max_log_length=1000):
405
428
DBusGMainLoop(set_as_default=True)
406
429
407
430
self.screen = urwid.curses_display.Screen()
410
433
("normal",
411
434
"default", "default", None),
412
435
("bold",
413
"bold", "default", "bold"),
436
"default", "default", "bold"),
414
437
("underline-blink",
415
"underline,blink", "default", "underline,blink"),
438
"default", "default", "underline"),
416
439
("standout",
417
"standout", "default", "standout"),
440
"default", "default", "standout"),
418
441
("bold-underline-blink",
419
"bold,underline,blink", "default", "bold,underline,blink"),
442
"default", "default", ("bold", "underline")),
420
443
("bold-standout",
421
"bold,standout", "default", "bold,standout"),
444
"default", "default", ("bold", "standout")),
422
445
("underline-blink-standout",
423
"underline,blink,standout", "default",
424
"underline,blink,standout"),
446
"default", "default", ("underline", "standout")),
425
447
("bold-underline-blink-standout",
426
"bold,underline,blink,standout", "default",
427
"bold,underline,blink,standout"),
448
"default", "default", ("bold", "underline",
449
"standout")),
428
450
))
429
451
430
452
if urwid.supports_unicode():
445
467
self.log = []
446
468
self.max_log_length = max_log_length
447
469
448
self.log_level = log_level
449
450
470
# We keep a reference to the log widget so we can remove it
451
471
# from the ListWalker without it getting destroyed
452
472
self.logbox = ConstrainedListBox(self.log)
466
486
self.main_loop = gobject.MainLoop()
467
487
468
488
def client_not_found(self, fingerprint, address):
469
self.log_message("Client with address {} and fingerprint {}"
470
" could not be found"
471
.format(address, fingerprint))
489
self.log_message(("Client with address %s and fingerprint %s"
490
" could not be found" % (address,
491
fingerprint)))
472
492
473
493
def rebuild(self):
474
494
"""This rebuilds the User Interface.
486
506
self.uilist.append(self.logbox)
487
507
self.topwidget = urwid.Pile(self.uilist)
488
508
489
def log_message(self, message, level=1):
490
"""Log message formatted with timestamp"""
491
if level < self.log_level:
492
return
509
def log_message(self, message):
493
510
timestamp = datetime.datetime.now().isoformat()
494
self.log_message_raw("{}: {}".format(timestamp, message),
495
level=level)
511
self.log_message_raw(timestamp + ": " + message)
496
512
497
def log_message_raw(self, markup, level=1):
513
def log_message_raw(self, markup):
498
514
"""Add a log message to the log buffer."""
499
if level < self.log_level:
500
return
501
515
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
502
516
if (self.max_log_length
503
517
and len(self.log) > self.max_log_length):
510
524
"""Toggle visibility of the log buffer."""
511
525
self.log_visible = not self.log_visible
512
526
self.rebuild()
513
self.log_message("Log visibility changed to: {}"
514
.format(self.log_visible), level=0)
527
#self.log_message("Log visibility changed to: "
528
# + unicode(self.log_visible))
515
529
516
530
def change_log_display(self):
517
531
"""Change type of log display.
522
536
self.log_wrap = "clip"
523
537
for textwidget in self.log:
524
538
textwidget.set_wrap_mode(self.log_wrap)
525
self.log_message("Wrap mode: {}".format(self.log_wrap),
526
level=0)
539
#self.log_message("Wrap mode: " + self.log_wrap)
527
540
528
541
def find_and_remove_client(self, path, name):
529
542
"""Find a client by its object path and remove it.
534
547
client = self.clients_dict[path]
535
548
except KeyError:
536
549
# not found?
537
self.log_message("Unknown client {!r} ({!r}) removed"
538
.format(name, path))
550
self.log_message("Unknown client %r (%r) removed", name,
551
path)
539
552
return
540
553
client.delete()
541
554
558
571
if path is None:
559
572
path = client.proxy.object_path
560
573
self.clients_dict[path] = client
561
self.clients.sort(key=lambda c: c.properties["Name"])
574
self.clients.sort(None, lambda c: c.properties["Name"])
562
575
self.refresh()
563
576
564
577
def remove_client(self, client, path=None):
566
579
if path is None:
567
580
path = client.proxy.object_path
568
581
del self.clients_dict[path]
582
if not self.clients_dict:
583
# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
584
# is completely emptied, we need to recreate it.
585
self.clients = urwid.SimpleListWalker([])
586
self.rebuild()
569
587
self.refresh()
570
588
571
589
def refresh(self):
584
602
try:
585
603
mandos_clients = (self.mandos_serv
586
604
.GetAllClientsWithProperties())
587
if not mandos_clients:
588
self.log_message_raw(("bold", "Note: Server has no clients."))
589
605
except dbus.exceptions.DBusException:
590
self.log_message_raw(("bold", "Note: No Mandos server running."))
591
606
mandos_clients = dbus.Dictionary()
592
607
593
608
(self.mandos_serv
605
620
self.client_not_found,
606
621
dbus_interface=server_interface,
607
622
byte_arrays=True))
608
for path, client in mandos_clients.items():
623
for path, client in mandos_clients.iteritems():
609
624
client_proxy_object = self.bus.get_object(self.busname,
610
625
path)
611
626
self.add_client(MandosClientWidget(server_proxy_object
620
635
logger
621
636
=self.log_message),
622
637
path=path)
623
638
624
639
self.refresh()
625
640
self._input_callback_tag = (gobject.io_add_watch
626
641
(sys.stdin.fileno(),
658
673
elif key == "window resize":
659
674
self.size = self.screen.get_cols_rows()
660
675
self.refresh()
661
elif key == "ctrl l":
662
self.screen.clear()
676
elif key == "\f": # Ctrl-L
663
677
self.refresh()
664
678
elif key == "l" or key == "D":
665
679
self.toggle_log_display()
677
691
"?: Help",
678
692
"l: Log window toggle",
679
693
"TAB: Switch window",
680
"w: Wrap (log lines)",
681
"v: Toggle verbose log",
682
))))
694
"w: Wrap (log)"))))
683
695
self.log_message_raw(("bold",
684
696
" "
685
697
.join(("Clients:",
698
710
else:
699
711
self.topwidget.set_focus(self.logbox)
700
712
self.refresh()
701
elif key == "v":
702
if self.log_level == 0:
703
self.log_level = 1
704
self.log_message("Verbose mode: Off")
705
else:
706
self.log_level = 0
707
self.log_message("Verbose mode: On")
708
713
#elif (key == "end" or key == "meta >" or key == "G"
709
714
# or key == ">"):
710
715
# pass # xxx end-of-buffer
733
738
ui.run()
734
739
except KeyboardInterrupt:
735
740
ui.screen.stop()
736
except Exception as e:
737
ui.log_message(str(e))
741
except Exception, e:
742
ui.log_message(unicode(e))
738
743
ui.screen.stop()
739
744
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0