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.29
- compare with another revision
- download diff
- download tarball
- view history from revision 237.4.29
- Committer: Teddy Hogeborn
- Date: 2012-02-21 21:27:14 UTC
- mfrom: (237.6.1 nmu)
- mto: (237.4.31 release)
- mto: This revision was merged to the branch mainline in revision 560.
- Revision ID: teddy@recompile.se-20120221212714-40iub281d4yvrk9r
Tags: version-1.5.3-1.1
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.
369
396
else:
370
397
return key
371
398
372
def properties_changed(self, interface, properties, invalidated):
373
"""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.
374
402
This overrides the method from MandosClientPropertyCache"""
375
old_values = { key: self.properties.get(key)
376
for key in properties.keys() }
377
super(MandosClientWidget, self).properties_changed(
378
interface, properties, invalidated)
379
if any(old_values[key] != self.properties.get(key)
380
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:
381
408
self.update()
382
409
383
410
386
413
"down" key presses, thus not allowing any containing widgets to
387
414
use them as an excuse to shift focus away from this widget.
388
415
"""
389
def keypress(self, *args, **kwargs):
390
ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
416
def keypress(self, maxcolrow, key):
417
ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)
391
418
if ret in ("up", "down"):
392
419
return
393
420
return ret
397
424
"""This is the entire user interface - the whole screen
398
425
with boxes, lists of client widgets, etc.
399
426
"""
400
def __init__(self, max_log_length=1000, log_level=1):
427
def __init__(self, max_log_length=1000):
401
428
DBusGMainLoop(set_as_default=True)
402
429
403
430
self.screen = urwid.curses_display.Screen()
406
433
("normal",
407
434
"default", "default", None),
408
435
("bold",
409
"bold", "default", "bold"),
436
"default", "default", "bold"),
410
437
("underline-blink",
411
"underline,blink", "default", "underline,blink"),
438
"default", "default", "underline"),
412
439
("standout",
413
"standout", "default", "standout"),
440
"default", "default", "standout"),
414
441
("bold-underline-blink",
415
"bold,underline,blink", "default", "bold,underline,blink"),
442
"default", "default", ("bold", "underline")),
416
443
("bold-standout",
417
"bold,standout", "default", "bold,standout"),
444
"default", "default", ("bold", "standout")),
418
445
("underline-blink-standout",
419
"underline,blink,standout", "default",
420
"underline,blink,standout"),
446
"default", "default", ("underline", "standout")),
421
447
("bold-underline-blink-standout",
422
"bold,underline,blink,standout", "default",
423
"bold,underline,blink,standout"),
448
"default", "default", ("bold", "underline",
449
"standout")),
424
450
))
425
451
426
452
if urwid.supports_unicode():
441
467
self.log = []
442
468
self.max_log_length = max_log_length
443
469
444
self.log_level = log_level
445
446
470
# We keep a reference to the log widget so we can remove it
447
471
# from the ListWalker without it getting destroyed
448
472
self.logbox = ConstrainedListBox(self.log)
462
486
self.main_loop = gobject.MainLoop()
463
487
464
488
def client_not_found(self, fingerprint, address):
465
self.log_message("Client with address {} and fingerprint {}"
466
" could not be found"
467
.format(address, fingerprint))
489
self.log_message(("Client with address %s and fingerprint %s"
490
" could not be found" % (address,
491
fingerprint)))
468
492
469
493
def rebuild(self):
470
494
"""This rebuilds the User Interface.
482
506
self.uilist.append(self.logbox)
483
507
self.topwidget = urwid.Pile(self.uilist)
484
508
485
def log_message(self, message, level=1):
486
"""Log message formatted with timestamp"""
487
if level < self.log_level:
488
return
509
def log_message(self, message):
489
510
timestamp = datetime.datetime.now().isoformat()
490
self.log_message_raw("{}: {}".format(timestamp, message),
491
level=level)
511
self.log_message_raw(timestamp + ": " + message)
492
512
493
def log_message_raw(self, markup, level=1):
513
def log_message_raw(self, markup):
494
514
"""Add a log message to the log buffer."""
495
if level < self.log_level:
496
return
497
515
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
498
516
if (self.max_log_length
499
517
and len(self.log) > self.max_log_length):
506
524
"""Toggle visibility of the log buffer."""
507
525
self.log_visible = not self.log_visible
508
526
self.rebuild()
509
self.log_message("Log visibility changed to: {}"
510
.format(self.log_visible), level=0)
527
#self.log_message("Log visibility changed to: "
528
# + unicode(self.log_visible))
511
529
512
530
def change_log_display(self):
513
531
"""Change type of log display.
518
536
self.log_wrap = "clip"
519
537
for textwidget in self.log:
520
538
textwidget.set_wrap_mode(self.log_wrap)
521
self.log_message("Wrap mode: {}".format(self.log_wrap),
522
level=0)
539
#self.log_message("Wrap mode: " + self.log_wrap)
523
540
524
541
def find_and_remove_client(self, path, name):
525
542
"""Find a client by its object path and remove it.
530
547
client = self.clients_dict[path]
531
548
except KeyError:
532
549
# not found?
533
self.log_message("Unknown client {!r} ({!r}) removed"
534
.format(name, path))
550
self.log_message("Unknown client %r (%r) removed", name,
551
path)
535
552
return
536
553
client.delete()
537
554
554
571
if path is None:
555
572
path = client.proxy.object_path
556
573
self.clients_dict[path] = client
557
self.clients.sort(key=lambda c: c.properties["Name"])
574
self.clients.sort(None, lambda c: c.properties["Name"])
558
575
self.refresh()
559
576
560
577
def remove_client(self, client, path=None):
562
579
if path is None:
563
580
path = client.proxy.object_path
564
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()
565
587
self.refresh()
566
588
567
589
def refresh(self):
580
602
try:
581
603
mandos_clients = (self.mandos_serv
582
604
.GetAllClientsWithProperties())
583
if not mandos_clients:
584
self.log_message_raw(("bold", "Note: Server has no clients."))
585
605
except dbus.exceptions.DBusException:
586
self.log_message_raw(("bold", "Note: No Mandos server running."))
587
606
mandos_clients = dbus.Dictionary()
588
607
589
608
(self.mandos_serv
601
620
self.client_not_found,
602
621
dbus_interface=server_interface,
603
622
byte_arrays=True))
604
for path, client in mandos_clients.items():
623
for path, client in mandos_clients.iteritems():
605
624
client_proxy_object = self.bus.get_object(self.busname,
606
625
path)
607
626
self.add_client(MandosClientWidget(server_proxy_object
616
635
logger
617
636
=self.log_message),
618
637
path=path)
619
638
620
639
self.refresh()
621
640
self._input_callback_tag = (gobject.io_add_watch
622
641
(sys.stdin.fileno(),
654
673
elif key == "window resize":
655
674
self.size = self.screen.get_cols_rows()
656
675
self.refresh()
657
elif key == "ctrl l":
658
self.screen.clear()
676
elif key == "\f": # Ctrl-L
659
677
self.refresh()
660
678
elif key == "l" or key == "D":
661
679
self.toggle_log_display()
673
691
"?: Help",
674
692
"l: Log window toggle",
675
693
"TAB: Switch window",
676
"w: Wrap (log lines)",
677
"v: Toggle verbose log",
678
))))
694
"w: Wrap (log)"))))
679
695
self.log_message_raw(("bold",
680
696
" "
681
697
.join(("Clients:",
694
710
else:
695
711
self.topwidget.set_focus(self.logbox)
696
712
self.refresh()
697
elif key == "v":
698
if self.log_level == 0:
699
self.log_level = 1
700
self.log_message("Verbose mode: Off")
701
else:
702
self.log_level = 0
703
self.log_message("Verbose mode: On")
704
713
#elif (key == "end" or key == "meta >" or key == "G"
705
714
# or key == ">"):
706
715
# pass # xxx end-of-buffer
729
738
ui.run()
730
739
except KeyboardInterrupt:
731
740
ui.screen.stop()
732
except Exception as e:
733
ui.log_message(str(e))
741
except Exception, e:
742
ui.log_message(unicode(e))
734
743
ui.screen.stop()
735
744
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0