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 550
- compare with another revision
- download diff
- download tarball
- view history from revision 550
- Committer: Teddy Hogeborn
- Date: 2012-01-01 20:45:53 UTC
- Revision ID: teddy@recompile.se-20120101204553-f1zlty873gswtf5n
* README: Hint that the intro(8mandos) manual page is in the server
package.
package.
- files added:
- DBUS-API
- debian/source
- network-hooks.d
- files modified:
- .bzrignore
added
removed
mandos-monitor
1
1
#!/usr/bin/python
2
2
# -*- mode: python; coding: utf-8 -*-
3
#
4
# Mandos Monitor - Control and monitor the Mandos server
5
#
6
# Copyright © 2009-2012 Teddy Hogeborn
7
# Copyright © 2009-2012 Björn Påhlsson
8
#
9
# This program is free software: you can redistribute it and/or modify
10
# it under the terms of the GNU General Public License as published by
11
# the Free Software Foundation, either version 3 of the License, or
12
# (at your option) any later version.
13
#
14
# This program is distributed in the hope that it will be useful,
15
# but WITHOUT ANY WARRANTY; without even the implied warranty of
16
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17
# GNU General Public License for more details.
18
#
19
# You should have received a copy of the GNU General Public License
20
# along with this program. If not, see <http://www.gnu.org/licenses/>.
21
#
22
# Contact the authors at <mandos@recompile.se>.
23
#
3
24
4
from __future__ import division, absolute_import, with_statement
25
from __future__ import (division, absolute_import, print_function,
26
unicode_literals)
5
27
6
28
import sys
7
29
import os
19
41
20
42
import UserList
21
43
44
import locale
45
46
locale.setlocale(locale.LC_ALL, '')
47
48
import logging
49
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
50
22
51
# Some useful constants
23
domain = 'se.bsnet.fukt'
52
domain = 'se.recompile'
24
53
server_interface = domain + '.Mandos'
25
54
client_interface = domain + '.Mandos.Client'
26
version = "1.0.14"
55
version = "1.5.0"
27
56
28
57
# Always run in monochrome mode
29
58
urwid.curses_display.curses.has_colors = lambda : False
33
62
urwid.curses_display.curses.A_UNDERLINE |= (
34
63
urwid.curses_display.curses.A_BLINK)
35
64
65
def isoformat_to_datetime(iso):
66
"Parse an ISO 8601 date string to a datetime.datetime()"
67
if not iso:
68
return None
69
d, t = iso.split("T", 1)
70
year, month, day = d.split("-", 2)
71
hour, minute, second = t.split(":", 2)
72
second, fraction = divmod(float(second), 1)
73
return datetime.datetime(int(year),
74
int(month),
75
int(day),
76
int(hour),
77
int(minute),
78
int(second), # Whole seconds
79
int(fraction*1000000)) # Microseconds
80
36
81
class MandosClientPropertyCache(object):
37
82
"""This wraps a Mandos Client D-Bus proxy object, caches the
38
83
properties and calls a hook function when any of them are
39
84
changed.
40
85
"""
41
def __init__(self, proxy_object=None, properties=None, *args,
42
**kwargs):
86
def __init__(self, proxy_object=None, *args, **kwargs):
43
87
self.proxy = proxy_object # Mandos Client proxy object
44
88
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)
89
self.properties = dict()
90
self.property_changed_match = (
91
self.proxy.connect_to_signal("PropertyChanged",
92
self.property_changed,
93
client_interface,
94
byte_arrays=True))
53
95
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)
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)
61
103
62
104
def property_changed(self, property=None, value=None):
63
105
"""This is called whenever we get a PropertyChanged signal
65
107
"""
66
108
# Update properties dict with new value
67
109
self.properties[property] = value
110
111
def delete(self, *args, **kwargs):
112
self.property_changed_match.remove()
113
super(MandosClientPropertyCache, self).__init__(
114
*args, **kwargs)
68
115
69
116
70
117
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
82
129
# Logger
83
130
self.logger = logger
84
131
132
self._update_timer_callback_tag = None
133
self._update_timer_callback_lock = 0
134
self.last_checker_failed = False
135
85
136
# The widget shown normally
86
self._text_widget = urwid.Text(u"")
137
self._text_widget = urwid.Text("")
87
138
# The widget shown when we have focus
88
self._focus_text_widget = urwid.Text(u"")
139
self._focus_text_widget = urwid.Text("")
89
140
super(MandosClientWidget, self).__init__(
90
141
update_hook=update_hook, delete_hook=delete_hook,
91
142
*args, **kwargs)
92
143
self.update()
93
144
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)
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
164
self.match_objects = (
165
self.proxy.connect_to_signal("CheckerCompleted",
166
self.checker_completed,
167
client_interface,
168
byte_arrays=True),
169
self.proxy.connect_to_signal("CheckerStarted",
170
self.checker_started,
171
client_interface,
172
byte_arrays=True),
173
self.proxy.connect_to_signal("GotSecret",
174
self.got_secret,
175
client_interface,
176
byte_arrays=True),
177
self.proxy.connect_to_signal("NeedApproval",
178
self.need_approval,
179
client_interface,
180
byte_arrays=True),
181
self.proxy.connect_to_signal("Rejected",
182
self.rejected,
183
client_interface,
184
byte_arrays=True))
185
#self.logger('Created client %s' % (self.properties["Name"]))
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
193
def using_timer(self, flag):
194
"""Call this method with True or False when timer should be
195
activated or deactivated.
196
"""
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:
203
# Will update the shown timer value every second
204
self._update_timer_callback_tag = (gobject.timeout_add
205
(1000,
206
self.update_timer))
207
elif old and self._update_timer_callback_lock == 0:
208
gobject.source_remove(self._update_timer_callback_tag)
209
self._update_timer_callback_tag = None
110
210
111
211
def checker_completed(self, exitstatus, condition, command):
112
212
if exitstatus == 0:
113
self.logger(u'Checker for client %s (command "%s")'
114
u' was successful'
115
% (self.properties[u"name"], command))
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))
219
self.update()
116
220
return
221
# Checker failed
222
if not self.last_checker_failed:
223
self.last_checker_failed = True
224
self.using_timer(True)
117
225
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,
226
self.logger('Checker for client %s (command "%s")'
227
' failed with exit code %s'
228
% (self.properties["Name"], command,
121
229
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,
230
elif os.WIFSIGNALED(condition):
231
self.logger('Checker for client %s (command "%s")'
232
' was killed by signal %s'
233
% (self.properties["Name"], command,
127
234
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')
235
elif os.WCOREDUMP(condition):
236
self.logger('Checker for client %s (command "%s")'
237
' dumped core'
238
% (self.properties["Name"], command))
239
else:
240
self.logger('Checker for client %s completed'
241
' mysteriously')
242
self.update()
134
243
135
244
def checker_started(self, command):
136
self.logger(u'Client %s started checker "%s"'
137
% (self.properties[u"name"], unicode(command)))
245
"""Server signals that a checker started. This could be useful
246
to log in the future. """
247
#self.logger('Client %s started checker "%s"'
248
# % (self.properties["Name"], unicode(command)))
249
pass
138
250
139
251
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"])
252
self.last_checker_failed = False
253
self.logger('Client %s received its secret'
254
% self.properties["Name"])
255
256
def need_approval(self, timeout, default):
257
if not default:
258
message = 'Client %s needs approval within %s seconds'
259
else:
260
message = 'Client %s will get its secret in %s seconds'
261
self.logger(message
262
% (self.properties["Name"], timeout/1000))
263
self.using_timer(True)
264
265
def rejected(self, reason):
266
self.logger('Client %s was rejected; reason: %s'
267
% (self.properties["Name"], reason))
146
268
147
269
def selectable(self):
148
270
"""Make this a "selectable" widget.
149
271
This overrides the method from urwid.FlowWidget."""
150
272
return True
151
273
152
def rows(self, (maxcol,), focus=False):
274
def rows(self, maxcolrow, focus=False):
153
275
"""How many rows this widget will occupy might depend on
154
276
whether we have focus or not.
155
277
This overrides the method from urwid.FlowWidget"""
156
return self.current_widget(focus).rows((maxcol,), focus=focus)
278
return self.current_widget(focus).rows(maxcolrow, focus=focus)
157
279
158
280
def current_widget(self, focus=False):
159
281
if focus or self.opened:
163
285
def update(self):
164
286
"Called when what is visible on the screen should be updated."
165
287
# 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",
288
with_standout = { "normal": "standout",
289
"bold": "bold-standout",
290
"underline-blink":
291
"underline-blink-standout",
292
"bold-underline-blink":
293
"bold-underline-blink-standout",
172
294
}
173
295
174
296
# 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")})
297
298
# Base part of a client. Name!
299
base = ('%(name)s: '
300
% {"name": self.properties["Name"]})
301
if not self.properties["Enabled"]:
302
message = "DISABLED"
303
elif self.properties["ApprovalPending"]:
304
timeout = datetime.timedelta(milliseconds
305
= self.properties
306
["ApprovalDelay"])
307
last_approval_request = isoformat_to_datetime(
308
self.properties["LastApprovalRequest"])
309
if last_approval_request is not None:
310
timer = timeout - (datetime.datetime.utcnow()
311
- last_approval_request)
312
else:
313
timer = datetime.timedelta()
314
if self.properties["ApprovedByDefault"]:
315
message = "Approval in %s. (d)eny?"
316
else:
317
message = "Denial in %s. (a)pprove?"
318
message = message % unicode(timer).rsplit(".", 1)[0]
319
elif self.last_checker_failed:
320
# When checker has failed, print a timer until client expires
321
expires = self.properties["Expires"]
322
if expires == "":
323
timer = datetime.timedelta(0)
324
else:
325
expires = datetime.datetime.strptime(expires,
326
'%Y-%m-%dT%H:%M:%S.%f')
327
timer = expires - datetime.datetime.utcnow()
328
message = ('A checker has failed! Time until client'
329
' gets disabled: %s'
330
% unicode(timer).rsplit(".", 1)[0])
331
else:
332
message = "enabled"
333
self._text = "%s%s" % (base, message)
334
181
335
if not urwid.supports_unicode():
182
336
self._text = self._text.encode("ascii", "replace")
183
textlist = [(u"normal", self._text)]
337
textlist = [("normal", self._text)]
184
338
self._text_widget.set_text(textlist)
185
339
self._focus_text_widget.set_text([(with_standout[text[0]],
186
340
text[1])
194
348
if self.update_hook is not None:
195
349
self.update_hook()
196
350
197
def delete(self):
351
def update_timer(self):
352
"""called by gobject. Will indefinitely loop until
353
gobject.source_remove() on tag is called"""
354
self.update()
355
return True # Keep calling this
356
357
def delete(self, *args, **kwargs):
358
if self._update_timer_callback_tag is not None:
359
gobject.source_remove(self._update_timer_callback_tag)
360
self._update_timer_callback_tag = None
361
for match in self.match_objects:
362
match.remove()
363
self.match_objects = ()
198
364
if self.delete_hook is not None:
199
365
self.delete_hook(self)
366
return super(MandosClientWidget, self).delete(*args, **kwargs)
200
367
201
def render(self, (maxcol,), focus=False):
368
def render(self, maxcolrow, focus=False):
202
369
"""Render differently if we have focus.
203
370
This overrides the method from urwid.FlowWidget"""
204
return self.current_widget(focus).render((maxcol,),
371
return self.current_widget(focus).render(maxcolrow,
205
372
focus=focus)
206
373
207
def keypress(self, (maxcol,), key):
374
def keypress(self, maxcolrow, key):
208
375
"""Handle keys.
209
376
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":
377
if key == "+":
378
self.proxy.Enable(dbus_interface = client_interface,
379
ignore_reply=True)
380
elif key == "-":
381
self.proxy.Disable(dbus_interface = client_interface,
382
ignore_reply=True)
383
elif key == "a":
384
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
385
dbus_interface = client_interface,
386
ignore_reply=True)
387
elif key == "d":
388
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
389
dbus_interface = client_interface,
390
ignore_reply=True)
391
elif key == "R" or key == "_" or key == "ctrl k":
215
392
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()
393
.object_path,
394
ignore_reply=True)
395
elif key == "s":
396
self.proxy.StartChecker(dbus_interface = client_interface,
397
ignore_reply=True)
398
elif key == "S":
399
self.proxy.StopChecker(dbus_interface = client_interface,
400
ignore_reply=True)
401
elif key == "C":
402
self.proxy.CheckedOK(dbus_interface = client_interface,
403
ignore_reply=True)
223
404
# xxx
224
# elif key == u"p" or key == "=":
405
# elif key == "p" or key == "=":
225
406
# self.proxy.pause()
226
# elif key == u"u" or key == ":":
407
# elif key == "u" or key == ":":
227
408
# self.proxy.unpause()
228
# elif key == u"RET":
409
# elif key == "RET":
229
410
# self.open()
230
411
else:
231
412
return key
247
428
"down" key presses, thus not allowing any containing widgets to
248
429
use them as an excuse to shift focus away from this widget.
249
430
"""
250
def keypress(self, (maxcol, maxrow), key):
251
ret = super(ConstrainedListBox, self).keypress((maxcol, maxrow), key)
252
if ret in (u"up", u"down"):
431
def keypress(self, maxcolrow, key):
432
ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)
433
if ret in ("up", "down"):
253
434
return
254
435
return ret
255
436
264
445
self.screen = urwid.curses_display.Screen()
265
446
266
447
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")),
448
("normal",
449
"default", "default", None),
450
("bold",
451
"default", "default", "bold"),
452
("underline-blink",
453
"default", "default", "underline"),
454
("standout",
455
"default", "default", "standout"),
456
("bold-underline-blink",
457
"default", "default", ("bold", "underline")),
458
("bold-standout",
459
"default", "default", ("bold", "standout")),
460
("underline-blink-standout",
461
"default", "default", ("underline", "standout")),
462
("bold-underline-blink-standout",
463
"default", "default", ("bold", "underline",
464
"standout")),
284
465
))
285
466
286
467
if urwid.supports_unicode():
287
self.divider = u"─" # \u2500
288
#self.divider = u"━" # \u2501
468
self.divider = "─" # \u2500
469
#self.divider = "━" # \u2501
289
470
else:
290
#self.divider = u"-" # \u002d
291
self.divider = u"_" # \u005f
471
#self.divider = "-" # \u002d
472
self.divider = "_" # \u005f
292
473
293
474
self.screen.start()
294
475
308
489
# This keeps track of whether self.uilist currently has
309
490
# self.logbox in it or not
310
491
self.log_visible = True
311
self.log_wrap = u"any"
492
self.log_wrap = "any"
312
493
313
494
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"))
495
self.log_message_raw(("bold",
496
"Mandos Monitor version " + version))
497
self.log_message_raw(("bold",
498
"q: Quit ?: Help"))
318
499
319
500
self.busname = domain + '.Mandos'
320
501
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
502
364
503
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,
504
self.log_message(("Client with address %s and fingerprint %s"
505
" could not be found" % (address,
367
506
fingerprint)))
368
507
369
508
def rebuild(self):
371
510
Call this when the widget layout needs to change"""
372
511
self.uilist = []
373
512
#self.uilist.append(urwid.ListBox(self.clients))
374
self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),
513
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
514
clients),
375
515
#header=urwid.Divider(),
376
516
header=None,
377
footer=urwid.Divider(div_char=self.divider)))
517
footer=
518
urwid.Divider(div_char=
519
self.divider)))
378
520
if self.log_visible:
379
521
self.uilist.append(self.logbox)
380
pass
381
522
self.topwidget = urwid.Pile(self.uilist)
382
523
383
524
def log_message(self, message):
384
525
timestamp = datetime.datetime.now().isoformat()
385
self.log_message_raw(timestamp + u": " + message)
526
self.log_message_raw(timestamp + ": " + message)
386
527
387
528
def log_message_raw(self, markup):
388
529
"""Add a log message to the log buffer."""
391
532
and len(self.log) > self.max_log_length):
392
533
del self.log[0:len(self.log)-self.max_log_length-1]
393
534
self.logbox.set_focus(len(self.logbox.body.contents),
394
coming_from=u"above")
535
coming_from="above")
395
536
self.refresh()
396
537
397
538
def toggle_log_display(self):
398
539
"""Toggle visibility of the log buffer."""
399
540
self.log_visible = not self.log_visible
400
541
self.rebuild()
401
self.log_message(u"Log visibility changed to: "
402
+ unicode(self.log_visible))
542
#self.log_message("Log visibility changed to: "
543
# + unicode(self.log_visible))
403
544
404
545
def change_log_display(self):
405
546
"""Change type of log display.
406
547
Currently, this toggles wrapping of text lines."""
407
if self.log_wrap == u"clip":
408
self.log_wrap = u"any"
548
if self.log_wrap == "clip":
549
self.log_wrap = "any"
409
550
else:
410
self.log_wrap = u"clip"
551
self.log_wrap = "clip"
411
552
for textwidget in self.log:
412
553
textwidget.set_wrap_mode(self.log_wrap)
413
self.log_message(u"Wrap mode: " + self.log_wrap)
554
#self.log_message("Wrap mode: " + self.log_wrap)
414
555
415
556
def find_and_remove_client(self, path, name):
416
"""Find an client from its object path and remove it.
557
"""Find a client by its object path and remove it.
417
558
418
559
This is connected to the ClientRemoved signal from the
419
560
Mandos server object."""
421
562
client = self.clients_dict[path]
422
563
except KeyError:
423
564
# not found?
565
self.log_message("Unknown client %r (%r) removed", name,
566
path)
424
567
return
425
self.remove_client(client, path)
568
client.delete()
426
569
427
def add_new_client(self, path, properties):
570
def add_new_client(self, path):
428
571
client_proxy_object = self.bus.get_object(self.busname, path)
429
572
self.add_client(MandosClientWidget(server_proxy_object
430
573
=self.mandos_serv,
431
574
proxy_object
432
575
=client_proxy_object,
433
properties=properties,
434
576
update_hook
435
577
=self.refresh,
436
578
delete_hook
437
=self.remove_client),
579
=self.remove_client,
580
logger
581
=self.log_message),
438
582
path=path)
439
583
440
584
def add_client(self, client, path=None):
442
586
if path is None:
443
587
path = client.proxy.object_path
444
588
self.clients_dict[path] = client
445
self.clients.sort(None, lambda c: c.properties[u"name"])
589
self.clients.sort(None, lambda c: c.properties["Name"])
446
590
self.refresh()
447
591
448
592
def remove_client(self, client, path=None):
464
608
465
609
def run(self):
466
610
"""Start the main loop and exit when it's done."""
611
self.bus = dbus.SystemBus()
612
mandos_dbus_objc = self.bus.get_object(
613
self.busname, "/", follow_name_owner_changes=True)
614
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
615
dbus_interface
616
= server_interface)
617
try:
618
mandos_clients = (self.mandos_serv
619
.GetAllClientsWithProperties())
620
except dbus.exceptions.DBusException:
621
mandos_clients = dbus.Dictionary()
622
623
(self.mandos_serv
624
.connect_to_signal("ClientRemoved",
625
self.find_and_remove_client,
626
dbus_interface=server_interface,
627
byte_arrays=True))
628
(self.mandos_serv
629
.connect_to_signal("ClientAdded",
630
self.add_new_client,
631
dbus_interface=server_interface,
632
byte_arrays=True))
633
(self.mandos_serv
634
.connect_to_signal("ClientNotFound",
635
self.client_not_found,
636
dbus_interface=server_interface,
637
byte_arrays=True))
638
for path, client in mandos_clients.iteritems():
639
client_proxy_object = self.bus.get_object(self.busname,
640
path)
641
self.add_client(MandosClientWidget(server_proxy_object
642
=self.mandos_serv,
643
proxy_object
644
=client_proxy_object,
645
properties=client,
646
update_hook
647
=self.refresh,
648
delete_hook
649
=self.remove_client,
650
logger
651
=self.log_message),
652
path=path)
653
467
654
self.refresh()
468
655
self._input_callback_tag = (gobject.io_add_watch
469
656
(sys.stdin.fileno(),
479
666
480
667
def process_input(self, source, condition):
481
668
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
669
translations = { "ctrl n": "down", # Emacs
670
"ctrl p": "up", # Emacs
671
"ctrl v": "page down", # Emacs
672
"meta v": "page up", # Emacs
673
" ": "page down", # less
674
"f": "page down", # less
675
"b": "page up", # less
676
"j": "down", # vi
677
"k": "up", # vi
491
678
}
492
679
for key in keys:
493
680
try:
495
682
except KeyError: # :-)
496
683
pass
497
684
498
if key == u"q" or key == u"Q":
685
if key == "q" or key == "Q":
499
686
self.stop()
500
687
break
501
elif key == u"window resize":
688
elif key == "window resize":
502
689
self.size = self.screen.get_cols_rows()
503
690
self.refresh()
504
elif key == u"\f": # Ctrl-L
691
elif key == "\f": # Ctrl-L
505
692
self.refresh()
506
elif key == u"l" or key == u"D":
693
elif key == "l" or key == "D":
507
694
self.toggle_log_display()
508
695
self.refresh()
509
elif key == u"w" or key == u"i":
696
elif key == "w" or key == "i":
510
697
self.change_log_display()
511
698
self.refresh()
512
elif key == u"?" or key == u"f1" or key == u"esc":
699
elif key == "?" or key == "f1" or key == "esc":
513
700
if not self.log_visible:
514
701
self.log_visible = True
515
702
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"))))
703
self.log_message_raw(("bold",
704
" ".
705
join(("q: Quit",
706
"?: Help",
707
"l: Log window toggle",
708
"TAB: Switch window",
709
"w: Wrap (log)"))))
710
self.log_message_raw(("bold",
711
" "
712
.join(("Clients:",
713
"+: Enable",
714
"-: Disable",
715
"R: Remove",
716
"s: Start new checker",
717
"S: Stop checker",
718
"C: Checker OK",
719
"a: Approve",
720
"d: Deny"))))
532
721
self.refresh()
533
elif key == u"tab":
722
elif key == "tab":
534
723
if self.topwidget.get_focus() is self.logbox:
535
724
self.topwidget.set_focus(0)
536
725
else:
537
726
self.topwidget.set_focus(self.logbox)
538
727
self.refresh()
539
#elif (key == u"end" or key == u"meta >" or key == u"G"
540
# or key == u">"):
728
#elif (key == "end" or key == "meta >" or key == "G"
729
# or key == ">"):
541
730
# pass # xxx end-of-buffer
542
#elif (key == u"home" or key == u"meta <" or key == u"g"
543
# or key == u"<"):
731
#elif (key == "home" or key == "meta <" or key == "g"
732
# or key == "<"):
544
733
# pass # xxx beginning-of-buffer
545
#elif key == u"ctrl e" or key == u"$":
734
#elif key == "ctrl e" or key == "$":
546
735
# pass # xxx move-end-of-line
547
#elif key == u"ctrl a" or key == u"^":
736
#elif key == "ctrl a" or key == "^":
548
737
# pass # xxx move-beginning-of-line
549
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
738
#elif key == "ctrl b" or key == "meta (" or key == "h":
550
739
# pass # xxx left
551
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
740
#elif key == "ctrl f" or key == "meta )" or key == "l":
552
741
# pass # xxx right
553
#elif key == u"a":
742
#elif key == "a":
554
743
# pass # scroll up log
555
#elif key == u"z":
744
#elif key == "z":
556
745
# pass # scroll down log
557
746
elif self.topwidget.selectable():
558
747
self.topwidget.keypress(self.size, key)
562
751
ui = UserInterface()
563
752
try:
564
753
ui.run()
565
except:
754
except KeyboardInterrupt:
755
ui.screen.stop()
756
except Exception, e:
757
ui.log_message(unicode(e))
566
758
ui.screen.stop()
567
759
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0