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 561
- compare with another revision
- download diff
- download tarball
- view history from revision 561
- Committer: Teddy Hogeborn
- Date: 2012-02-26 11:49:48 UTC
- mfrom: (560.1.2 deprecate-dbus)
- Revision ID: teddy@recompile.se-20120226114948-eho4a6wn5ock5h7g
Merge D-Bus interface annotations and D-Bus interface deprecations.
- 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.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
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
211
if os.WIFEXITED(condition):
185
self.logger('Checker for client {} (command "{}") failed'
186
' with exit code {}'
187
.format(self.properties["Name"], command,
188
os.WEXITSTATUS(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)))
189
216
elif os.WIFSIGNALED(condition):
190
self.logger('Checker for client {} (command "{}") was'
191
' killed by signal {}'
192
.format(self.properties["Name"], command,
193
os.WTERMSIG(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)))
194
221
elif os.WCOREDUMP(condition):
195
self.logger('Checker for client {} (command "{}") dumped'
196
' core'.format(self.properties["Name"],
197
command))
222
self.logger('Checker for client %s (command "%s")'
223
' dumped core'
224
% (self.properties["Name"], command))
198
225
else:
199
self.logger('Checker for client {} completed'
200
' mysteriously'
201
.format(self.properties["Name"]))
226
self.logger('Checker for client %s completed'
227
' mysteriously')
202
228
self.update()
203
229
204
230
def checker_started(self, command):
205
"""Server signals that a checker started."""
206
self.logger('Client {} started checker "{}"'
207
.format(self.properties["Name"],
208
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
209
236
210
237
def got_secret(self):
211
self.logger('Client {} received its secret'
212
.format(self.properties["Name"]))
238
self.logger('Client %s received its secret'
239
% self.properties["Name"])
213
240
214
241
def need_approval(self, timeout, default):
215
242
if not default:
216
message = 'Client {} needs approval within {} seconds'
243
message = 'Client %s needs approval within %s seconds'
217
244
else:
218
message = 'Client {} will get its secret in {} seconds'
219
self.logger(message.format(self.properties["Name"],
220
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)
221
249
222
250
def rejected(self, reason):
223
self.logger('Client {} was rejected; reason: {}'
224
.format(self.properties["Name"], reason))
251
self.logger('Client %s was rejected; reason: %s'
252
% (self.properties["Name"], reason))
225
253
226
254
def selectable(self):
227
255
"""Make this a "selectable" widget.
249
277
"bold-underline-blink":
250
278
"bold-underline-blink-standout",
251
279
}
252
280
253
281
# Rebuild focus and non-focus widgets using current properties
254
282
255
283
# Base part of a client. Name!
256
base = '{name}: '.format(name=self.properties["Name"])
284
base = ('%(name)s: '
285
% {"name": self.properties["Name"]})
257
286
if not self.properties["Enabled"]:
258
287
message = "DISABLED"
259
self.using_timer(False)
260
288
elif self.properties["ApprovalPending"]:
261
289
timeout = datetime.timedelta(milliseconds
262
290
= self.properties
264
292
last_approval_request = isoformat_to_datetime(
265
293
self.properties["LastApprovalRequest"])
266
294
if last_approval_request is not None:
267
timer = max(timeout - (datetime.datetime.utcnow()
268
- last_approval_request),
269
datetime.timedelta())
295
timer = timeout - (datetime.datetime.utcnow()
296
- last_approval_request)
270
297
else:
271
298
timer = datetime.timedelta()
272
299
if self.properties["ApprovedByDefault"]:
273
message = "Approval in {}. (d)eny?"
300
message = "Approval in %s. (d)eny?"
274
301
else:
275
message = "Denial in {}. (a)pprove?"
276
message = message.format(str(timer).rsplit(".", 1)[0])
277
self.using_timer(True)
302
message = "Denial in %s. (a)pprove?"
303
message = message % unicode(timer).rsplit(".", 1)[0]
278
304
elif self.properties["LastCheckerStatus"] != 0:
279
# When checker has failed, show timer until client expires
305
# When checker has failed, print a timer until client expires
280
306
expires = self.properties["Expires"]
281
307
if expires == "":
282
308
timer = datetime.timedelta(0)
283
309
else:
284
expires = (datetime.datetime.strptime
285
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
286
timer = max(expires - datetime.datetime.utcnow(),
287
datetime.timedelta())
310
expires = datetime.datetime.strptime(expires,
311
'%Y-%m-%dT%H:%M:%S.%f')
312
timer = expires - datetime.datetime.utcnow()
288
313
message = ('A checker has failed! Time until client'
289
' gets disabled: {}'
290
.format(str(timer).rsplit(".", 1)[0]))
291
self.using_timer(True)
314
' gets disabled: %s'
315
% unicode(timer).rsplit(".", 1)[0])
292
316
else:
293
317
message = "enabled"
294
self.using_timer(False)
295
self._text = "{}{}".format(base, message)
296
318
self._text = "%s%s" % (base, message)
319
297
320
if not urwid.supports_unicode():
298
321
self._text = self._text.encode("ascii", "replace")
299
322
textlist = [("normal", self._text)]
316
339
self.update()
317
340
return True # Keep calling this
318
341
319
def delete(self, **kwargs):
342
def delete(self, *args, **kwargs):
320
343
if self._update_timer_callback_tag is not None:
321
344
gobject.source_remove(self._update_timer_callback_tag)
322
345
self._update_timer_callback_tag = None
325
348
self.match_objects = ()
326
349
if self.delete_hook is not None:
327
350
self.delete_hook(self)
328
return super(MandosClientWidget, self).delete(**kwargs)
351
return super(MandosClientWidget, self).delete(*args, **kwargs)
329
352
330
353
def render(self, maxcolrow, focus=False):
331
354
"""Render differently if we have focus.
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