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 72
- compare with another revision
- download diff
- download tarball
- view history from revision 72
- Committer: Teddy Hogeborn
- Date: 2008-08-12 21:28:42 UTC
- Revision ID: teddy@fukt.bsnet.se-20080812212842-i96bjpu10iq0wpjd
* Makefile (uninstall-client): Refuse to uninstall if it is in use.
- files added:
- network-protocol.txt
- files removed:
- .bzr-builddeb
- debian
- debian/po
- files renamed:
- plugin-runner.c => mandos-client.c
- plugin-runner.xml => mandos-client.xml
- plugins.d/mandos-client.c => plugins.d/password-request.c
- plugins.d/mandos-client.xml => plugins.d/password-request.xml
- files modified:
- Makefile
added
removed
mandos-monitor
1
#!/usr/bin/python
2
# -*- mode: python; coding: utf-8 -*-
3
4
from __future__ import division, absolute_import, with_statement
5
6
import sys
7
import os
8
import signal
9
10
import datetime
11
12
import urwid.curses_display
13
import urwid
14
15
from dbus.mainloop.glib import DBusGMainLoop
16
import gobject
17
18
import dbus
19
20
import UserList
21
22
# Some useful constants
23
domain = 'se.bsnet.fukt'
24
server_interface = domain + '.Mandos'
25
client_interface = domain + '.Mandos.Client'
26
version = "1.0.14"
27
28
# Always run in monochrome mode
29
urwid.curses_display.curses.has_colors = lambda : False
30
31
# Urwid doesn't support blinking, but we want it. Since we have no
32
# use for underline on its own, we make underline also always blink.
33
urwid.curses_display.curses.A_UNDERLINE |= (
34
urwid.curses_display.curses.A_BLINK)
35
36
class MandosClientPropertyCache(object):
37
"""This wraps a Mandos Client D-Bus proxy object, caches the
38
properties and calls a hook function when any of them are
39
changed.
40
"""
41
def __init__(self, proxy_object=None, properties=None, *args,
42
**kwargs):
43
self.proxy = proxy_object # Mandos Client proxy object
44
45
if properties is None:
46
self.properties = dict()
47
else:
48
self.properties = properties
49
self.proxy.connect_to_signal(u"PropertyChanged",
50
self.property_changed,
51
client_interface,
52
byte_arrays=True)
53
54
if properties is None:
55
self.properties.update(self.proxy.GetAll(client_interface,
56
dbus_interface =
57
dbus.PROPERTIES_IFACE))
58
super(MandosClientPropertyCache, self).__init__(
59
proxy_object=proxy_object,
60
properties=properties, *args, **kwargs)
61
62
def property_changed(self, property=None, value=None):
63
"""This is called whenever we get a PropertyChanged signal
64
It updates the changed property in the "properties" dict.
65
"""
66
# Update properties dict with new value
67
self.properties[property] = value
68
69
70
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
71
"""A Mandos Client which is visible on the screen.
72
"""
73
74
def __init__(self, server_proxy_object=None, update_hook=None,
75
delete_hook=None, logger=None, *args, **kwargs):
76
# Called on update
77
self.update_hook = update_hook
78
# Called on delete
79
self.delete_hook = delete_hook
80
# Mandos Server proxy object
81
self.server_proxy_object = server_proxy_object
82
# Logger
83
self.logger = logger
84
85
# The widget shown normally
86
self._text_widget = urwid.Text(u"")
87
# The widget shown when we have focus
88
self._focus_text_widget = urwid.Text(u"")
89
super(MandosClientWidget, self).__init__(
90
update_hook=update_hook, delete_hook=delete_hook,
91
*args, **kwargs)
92
self.update()
93
self.opened = False
94
self.proxy.connect_to_signal(u"CheckerCompleted",
95
self.checker_completed,
96
client_interface,
97
byte_arrays=True)
98
self.proxy.connect_to_signal(u"CheckerStarted",
99
self.checker_started,
100
client_interface,
101
byte_arrays=True)
102
self.proxy.connect_to_signal(u"GotSecret",
103
self.got_secret,
104
client_interface,
105
byte_arrays=True)
106
self.proxy.connect_to_signal(u"Rejected",
107
self.rejected,
108
client_interface,
109
byte_arrays=True)
110
111
def checker_completed(self, exitstatus, condition, command):
112
if exitstatus == 0:
113
self.logger(u'Checker for client %s (command "%s")'
114
u' was successful'
115
% (self.properties[u"name"], command))
116
return
117
if os.WIFEXITED(condition):
118
self.logger(u'Checker for client %s (command "%s")'
119
u' failed with exit code %s'
120
% (self.properties[u"name"], command,
121
os.WEXITSTATUS(condition)))
122
return
123
if os.WIFSIGNALED(condition):
124
self.logger(u'Checker for client %s (command "%s")'
125
u' was killed by signal %s'
126
% (self.properties[u"name"], command,
127
os.WTERMSIG(condition)))
128
return
129
if os.WCOREDUMP(condition):
130
self.logger(u'Checker for client %s (command "%s")'
131
u' dumped core'
132
% (self.properties[u"name"], command))
133
self.logger(u'Checker for client %s completed mysteriously')
134
135
def checker_started(self, command):
136
self.logger(u'Client %s started checker "%s"'
137
% (self.properties[u"name"], unicode(command)))
138
139
def got_secret(self):
140
self.logger(u'Client %s received its secret'
141
% self.properties[u"name"])
142
143
def rejected(self):
144
self.logger(u'Client %s was rejected'
145
% self.properties[u"name"])
146
147
def selectable(self):
148
"""Make this a "selectable" widget.
149
This overrides the method from urwid.FlowWidget."""
150
return True
151
152
def rows(self, (maxcol,), focus=False):
153
"""How many rows this widget will occupy might depend on
154
whether we have focus or not.
155
This overrides the method from urwid.FlowWidget"""
156
return self.current_widget(focus).rows((maxcol,), focus=focus)
157
158
def current_widget(self, focus=False):
159
if focus or self.opened:
160
return self._focus_widget
161
return self._widget
162
163
def update(self):
164
"Called when what is visible on the screen should be updated."
165
# How to add standout mode to a style
166
with_standout = { u"normal": u"standout",
167
u"bold": u"bold-standout",
168
u"underline-blink":
169
u"underline-blink-standout",
170
u"bold-underline-blink":
171
u"bold-underline-blink-standout",
172
}
173
174
# Rebuild focus and non-focus widgets using current properties
175
self._text = (u'%(name)s: %(enabled)s'
176
% { u"name": self.properties[u"name"],
177
u"enabled":
178
(u"enabled"
179
if self.properties[u"enabled"]
180
else u"DISABLED")})
181
if not urwid.supports_unicode():
182
self._text = self._text.encode("ascii", "replace")
183
textlist = [(u"normal", self._text)]
184
self._text_widget.set_text(textlist)
185
self._focus_text_widget.set_text([(with_standout[text[0]],
186
text[1])
187
if isinstance(text, tuple)
188
else text
189
for text in textlist])
190
self._widget = self._text_widget
191
self._focus_widget = urwid.AttrWrap(self._focus_text_widget,
192
"standout")
193
# Run update hook, if any
194
if self.update_hook is not None:
195
self.update_hook()
196
197
def delete(self):
198
if self.delete_hook is not None:
199
self.delete_hook(self)
200
201
def render(self, (maxcol,), focus=False):
202
"""Render differently if we have focus.
203
This overrides the method from urwid.FlowWidget"""
204
return self.current_widget(focus).render((maxcol,),
205
focus=focus)
206
207
def keypress(self, (maxcol,), key):
208
"""Handle keys.
209
This overrides the method from urwid.FlowWidget"""
210
if key == u"e" or key == u"+":
211
self.proxy.Enable()
212
elif key == u"d" or key == u"-":
213
self.proxy.Disable()
214
elif key == u"r" or key == u"_" or key == u"ctrl k":
215
self.server_proxy_object.RemoveClient(self.proxy
216
.object_path)
217
elif key == u"s":
218
self.proxy.StartChecker()
219
elif key == u"S":
220
self.proxy.StopChecker()
221
elif key == u"C":
222
self.proxy.CheckedOK()
223
# xxx
224
# elif key == u"p" or key == "=":
225
# self.proxy.pause()
226
# elif key == u"u" or key == ":":
227
# self.proxy.unpause()
228
# elif key == u"RET":
229
# self.open()
230
else:
231
return key
232
233
def property_changed(self, property=None, value=None,
234
*args, **kwargs):
235
"""Call self.update() if old value is not new value.
236
This overrides the method from MandosClientPropertyCache"""
237
property_name = unicode(property)
238
old_value = self.properties.get(property_name)
239
super(MandosClientWidget, self).property_changed(
240
property=property, value=value, *args, **kwargs)
241
if self.properties.get(property_name) != old_value:
242
self.update()
243
244
245
class ConstrainedListBox(urwid.ListBox):
246
"""Like a normal urwid.ListBox, but will consume all "up" or
247
"down" key presses, thus not allowing any containing widgets to
248
use them as an excuse to shift focus away from this widget.
249
"""
250
def keypress(self, (maxcol, maxrow), key):
251
ret = super(ConstrainedListBox, self).keypress((maxcol, maxrow), key)
252
if ret in (u"up", u"down"):
253
return
254
return ret
255
256
257
class UserInterface(object):
258
"""This is the entire user interface - the whole screen
259
with boxes, lists of client widgets, etc.
260
"""
261
def __init__(self, max_log_length=1000):
262
DBusGMainLoop(set_as_default=True)
263
264
self.screen = urwid.curses_display.Screen()
265
266
self.screen.register_palette((
267
(u"normal",
268
u"default", u"default", None),
269
(u"bold",
270
u"default", u"default", u"bold"),
271
(u"underline-blink",
272
u"default", u"default", u"underline"),
273
(u"standout",
274
u"default", u"default", u"standout"),
275
(u"bold-underline-blink",
276
u"default", u"default", (u"bold", u"underline")),
277
(u"bold-standout",
278
u"default", u"default", (u"bold", u"standout")),
279
(u"underline-blink-standout",
280
u"default", u"default", (u"underline", u"standout")),
281
(u"bold-underline-blink-standout",
282
u"default", u"default", (u"bold", u"underline",
283
u"standout")),
284
))
285
286
if urwid.supports_unicode():
287
self.divider = u"─" # \u2500
288
#self.divider = u"━" # \u2501
289
else:
290
#self.divider = u"-" # \u002d
291
self.divider = u"_" # \u005f
292
293
self.screen.start()
294
295
self.size = self.screen.get_cols_rows()
296
297
self.clients = urwid.SimpleListWalker([])
298
self.clients_dict = {}
299
300
# We will add Text widgets to this list
301
self.log = []
302
self.max_log_length = max_log_length
303
304
# We keep a reference to the log widget so we can remove it
305
# from the ListWalker without it getting destroyed
306
self.logbox = ConstrainedListBox(self.log)
307
308
# This keeps track of whether self.uilist currently has
309
# self.logbox in it or not
310
self.log_visible = True
311
self.log_wrap = u"any"
312
313
self.rebuild()
314
self.log_message_raw((u"bold",
315
u"Mandos Monitor version " + version))
316
self.log_message_raw((u"bold",
317
u"q: Quit ?: Help"))
318
319
self.busname = domain + '.Mandos'
320
self.main_loop = gobject.MainLoop()
321
self.bus = dbus.SystemBus()
322
mandos_dbus_objc = self.bus.get_object(
323
self.busname, u"/", follow_name_owner_changes=True)
324
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
325
dbus_interface
326
= server_interface)
327
try:
328
mandos_clients = (self.mandos_serv
329
.GetAllClientsWithProperties())
330
except dbus.exceptions.DBusException:
331
mandos_clients = dbus.Dictionary()
332
333
(self.mandos_serv
334
.connect_to_signal(u"ClientRemoved",
335
self.find_and_remove_client,
336
dbus_interface=server_interface,
337
byte_arrays=True))
338
(self.mandos_serv
339
.connect_to_signal(u"ClientAdded",
340
self.add_new_client,
341
dbus_interface=server_interface,
342
byte_arrays=True))
343
(self.mandos_serv
344
.connect_to_signal(u"ClientNotFound",
345
self.client_not_found,
346
dbus_interface=server_interface,
347
byte_arrays=True))
348
for path, client in mandos_clients.iteritems():
349
client_proxy_object = self.bus.get_object(self.busname,
350
path)
351
self.add_client(MandosClientWidget(server_proxy_object
352
=self.mandos_serv,
353
proxy_object
354
=client_proxy_object,
355
properties=client,
356
update_hook
357
=self.refresh,
358
delete_hook
359
=self.remove_client,
360
logger
361
=self.log_message),
362
path=path)
363
364
def client_not_found(self, fingerprint, address):
365
self.log_message((u"Client with address %s and fingerprint %s"
366
u" could not be found" % (address,
367
fingerprint)))
368
369
def rebuild(self):
370
"""This rebuilds the User Interface.
371
Call this when the widget layout needs to change"""
372
self.uilist = []
373
#self.uilist.append(urwid.ListBox(self.clients))
374
self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),
375
#header=urwid.Divider(),
376
header=None,
377
footer=urwid.Divider(div_char=self.divider)))
378
if self.log_visible:
379
self.uilist.append(self.logbox)
380
pass
381
self.topwidget = urwid.Pile(self.uilist)
382
383
def log_message(self, message):
384
timestamp = datetime.datetime.now().isoformat()
385
self.log_message_raw(timestamp + u": " + message)
386
387
def log_message_raw(self, markup):
388
"""Add a log message to the log buffer."""
389
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
390
if (self.max_log_length
391
and len(self.log) > self.max_log_length):
392
del self.log[0:len(self.log)-self.max_log_length-1]
393
self.logbox.set_focus(len(self.logbox.body.contents),
394
coming_from=u"above")
395
self.refresh()
396
397
def toggle_log_display(self):
398
"""Toggle visibility of the log buffer."""
399
self.log_visible = not self.log_visible
400
self.rebuild()
401
self.log_message(u"Log visibility changed to: "
402
+ unicode(self.log_visible))
403
404
def change_log_display(self):
405
"""Change type of log display.
406
Currently, this toggles wrapping of text lines."""
407
if self.log_wrap == u"clip":
408
self.log_wrap = u"any"
409
else:
410
self.log_wrap = u"clip"
411
for textwidget in self.log:
412
textwidget.set_wrap_mode(self.log_wrap)
413
self.log_message(u"Wrap mode: " + self.log_wrap)
414
415
def find_and_remove_client(self, path, name):
416
"""Find an client from its object path and remove it.
417
418
This is connected to the ClientRemoved signal from the
419
Mandos server object."""
420
try:
421
client = self.clients_dict[path]
422
except KeyError:
423
# not found?
424
return
425
self.remove_client(client, path)
426
427
def add_new_client(self, path, properties):
428
client_proxy_object = self.bus.get_object(self.busname, path)
429
self.add_client(MandosClientWidget(server_proxy_object
430
=self.mandos_serv,
431
proxy_object
432
=client_proxy_object,
433
properties=properties,
434
update_hook
435
=self.refresh,
436
delete_hook
437
=self.remove_client),
438
path=path)
439
440
def add_client(self, client, path=None):
441
self.clients.append(client)
442
if path is None:
443
path = client.proxy.object_path
444
self.clients_dict[path] = client
445
self.clients.sort(None, lambda c: c.properties[u"name"])
446
self.refresh()
447
448
def remove_client(self, client, path=None):
449
self.clients.remove(client)
450
if path is None:
451
path = client.proxy.object_path
452
del self.clients_dict[path]
453
if not self.clients_dict:
454
# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
455
# is completely emptied, we need to recreate it.
456
self.clients = urwid.SimpleListWalker([])
457
self.rebuild()
458
self.refresh()
459
460
def refresh(self):
461
"""Redraw the screen"""
462
canvas = self.topwidget.render(self.size, focus=True)
463
self.screen.draw_screen(self.size, canvas)
464
465
def run(self):
466
"""Start the main loop and exit when it's done."""
467
self.refresh()
468
self._input_callback_tag = (gobject.io_add_watch
469
(sys.stdin.fileno(),
470
gobject.IO_IN,
471
self.process_input))
472
self.main_loop.run()
473
# Main loop has finished, we should close everything now
474
gobject.source_remove(self._input_callback_tag)
475
self.screen.stop()
476
477
def stop(self):
478
self.main_loop.quit()
479
480
def process_input(self, source, condition):
481
keys = self.screen.get_input()
482
translations = { u"ctrl n": u"down", # Emacs
483
u"ctrl p": u"up", # Emacs
484
u"ctrl v": u"page down", # Emacs
485
u"meta v": u"page up", # Emacs
486
u" ": u"page down", # less
487
u"f": u"page down", # less
488
u"b": u"page up", # less
489
u"j": u"down", # vi
490
u"k": u"up", # vi
491
}
492
for key in keys:
493
try:
494
key = translations[key]
495
except KeyError: # :-)
496
pass
497
498
if key == u"q" or key == u"Q":
499
self.stop()
500
break
501
elif key == u"window resize":
502
self.size = self.screen.get_cols_rows()
503
self.refresh()
504
elif key == u"\f": # Ctrl-L
505
self.refresh()
506
elif key == u"l" or key == u"D":
507
self.toggle_log_display()
508
self.refresh()
509
elif key == u"w" or key == u"i":
510
self.change_log_display()
511
self.refresh()
512
elif key == u"?" or key == u"f1" or key == u"esc":
513
if not self.log_visible:
514
self.log_visible = True
515
self.rebuild()
516
self.log_message_raw((u"bold",
517
u" ".
518
join((u"q: Quit",
519
u"?: Help",
520
u"l: Log window toggle",
521
u"TAB: Switch window",
522
u"w: Wrap (log)"))))
523
self.log_message_raw((u"bold",
524
u" "
525
.join((u"Clients:",
526
u"e: Enable",
527
u"d: Disable",
528
u"r: Remove",
529
u"s: Start new checker",
530
u"S: Stop checker",
531
u"C: Checker OK"))))
532
self.refresh()
533
elif key == u"tab":
534
if self.topwidget.get_focus() is self.logbox:
535
self.topwidget.set_focus(0)
536
else:
537
self.topwidget.set_focus(self.logbox)
538
self.refresh()
539
#elif (key == u"end" or key == u"meta >" or key == u"G"
540
# or key == u">"):
541
# pass # xxx end-of-buffer
542
#elif (key == u"home" or key == u"meta <" or key == u"g"
543
# or key == u"<"):
544
# pass # xxx beginning-of-buffer
545
#elif key == u"ctrl e" or key == u"$":
546
# pass # xxx move-end-of-line
547
#elif key == u"ctrl a" or key == u"^":
548
# pass # xxx move-beginning-of-line
549
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
550
# pass # xxx left
551
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
552
# pass # xxx right
553
#elif key == u"a":
554
# pass # scroll up log
555
#elif key == u"z":
556
# pass # scroll down log
557
elif self.topwidget.selectable():
558
self.topwidget.keypress(self.size, key)
559
self.refresh()
560
return True
561
562
ui = UserInterface()
563
try:
564
ui.run()
565
except:
566
ui.screen.stop()
567
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0