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 537
- compare with another revision
- download diff
- download tarball
- view history from revision 537
- Committer: Björn Påhlsson
- Date: 2011-12-26 15:23:45 UTC
- Revision ID: belorn@recompile.se-20111226152345-cd9mz98e7eiqbfbx
nicer stacktrace when mandos-monitor fail during startup
- files added:
- DBUS-API
- debian/source
- network-hooks.d
- files removed:
- plugins.d/plymouth
- 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-2011 Teddy Hogeborn
7
# Copyright © 2009-2011 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
21
43
22
44
import locale
23
45
24
locale.setlocale(locale.LC_ALL, u'')
46
locale.setlocale(locale.LC_ALL, '')
25
47
26
48
import logging
27
49
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
28
50
29
51
# Some useful constants
30
domain = 'se.bsnet.fukt'
52
domain = 'se.recompile'
31
53
server_interface = domain + '.Mandos'
32
54
client_interface = domain + '.Mandos.Client'
33
version = "1.0.15"
55
version = "1.4.1"
34
56
35
57
# Always run in monochrome mode
36
58
urwid.curses_display.curses.has_colors = lambda : False
40
62
urwid.curses_display.curses.A_UNDERLINE |= (
41
63
urwid.curses_display.curses.A_BLINK)
42
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
43
81
class MandosClientPropertyCache(object):
44
82
"""This wraps a Mandos Client D-Bus proxy object, caches the
45
83
properties and calls a hook function when any of them are
49
87
self.proxy = proxy_object # Mandos Client proxy object
50
88
51
89
self.properties = dict()
52
self.proxy.connect_to_signal(u"PropertyChanged",
53
self.property_changed,
54
client_interface,
55
byte_arrays=True)
90
self.property_changed_match = (
91
self.proxy.connect_to_signal("PropertyChanged",
92
self.property_changed,
93
client_interface,
94
byte_arrays=True))
56
95
57
96
self.properties.update(
58
97
self.proxy.GetAll(client_interface,
59
98
dbus_interface = dbus.PROPERTIES_IFACE))
60
super(MandosClientPropertyCache, self).__init__(
61
*args, **kwargs)
99
100
#XXX This breaks good super behaviour
101
# super(MandosClientPropertyCache, self).__init__(
102
# *args, **kwargs)
62
103
63
104
def property_changed(self, property=None, value=None):
64
105
"""This is called whenever we get a PropertyChanged signal
66
107
"""
67
108
# Update properties dict with new value
68
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)
69
115
70
116
71
117
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
83
129
# Logger
84
130
self.logger = logger
85
131
132
self._update_timer_callback_tag = None
133
self._update_timer_callback_lock = 0
134
self.last_checker_failed = False
135
86
136
# The widget shown normally
87
self._text_widget = urwid.Text(u"")
137
self._text_widget = urwid.Text("")
88
138
# The widget shown when we have focus
89
self._focus_text_widget = urwid.Text(u"")
139
self._focus_text_widget = urwid.Text("")
90
140
super(MandosClientWidget, self).__init__(
91
141
update_hook=update_hook, delete_hook=delete_hook,
92
142
*args, **kwargs)
93
143
self.update()
94
144
self.opened = False
95
self.proxy.connect_to_signal(u"CheckerCompleted",
96
self.checker_completed,
97
client_interface,
98
byte_arrays=True)
99
self.proxy.connect_to_signal(u"CheckerStarted",
100
self.checker_started,
101
client_interface,
102
byte_arrays=True)
103
self.proxy.connect_to_signal(u"GotSecret",
104
self.got_secret,
105
client_interface,
106
byte_arrays=True)
107
self.proxy.connect_to_signal(u"NeedApproval",
108
self.need_approval,
109
client_interface,
110
byte_arrays=True)
111
self.proxy.connect_to_signal(u"Rejected",
112
self.rejected,
113
client_interface,
114
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
115
210
116
211
def checker_completed(self, exitstatus, condition, command):
117
212
if exitstatus == 0:
118
#self.logger(u'Checker for client %s (command "%s")'
119
# u' was successful'
120
# % (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()
121
220
return
221
# Checker failed
222
if not self.last_checker_failed:
223
self.last_checker_failed = True
224
self.using_timer(True)
122
225
if os.WIFEXITED(condition):
123
self.logger(u'Checker for client %s (command "%s")'
124
u' failed with exit code %s'
125
% (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,
126
229
os.WEXITSTATUS(condition)))
127
return
128
if os.WIFSIGNALED(condition):
129
self.logger(u'Checker for client %s (command "%s")'
130
u' was killed by signal %s'
131
% (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,
132
234
os.WTERMSIG(condition)))
133
return
134
if os.WCOREDUMP(condition):
135
self.logger(u'Checker for client %s (command "%s")'
136
u' dumped core'
137
% (self.properties[u"name"], command))
138
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()
139
243
140
244
def checker_started(self, command):
141
#self.logger(u'Client %s started checker "%s"'
142
# % (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)))
143
249
pass
144
250
145
251
def got_secret(self):
146
self.logger(u'Client %s received its secret'
147
% self.properties[u"name"])
252
self.last_checker_failed = False
253
self.logger('Client %s received its secret'
254
% self.properties["Name"])
148
255
149
256
def need_approval(self, timeout, default):
150
257
if not default:
151
message = u'Client %s needs approval within %s seconds'
258
message = 'Client %s needs approval within %s seconds'
152
259
else:
153
message = u'Client %s will get its secret in %s seconds'
260
message = 'Client %s will get its secret in %s seconds'
154
261
self.logger(message
155
% (self.properties[u"name"], timeout/1000))
262
% (self.properties["Name"], timeout/1000))
263
self.using_timer(True)
156
264
157
265
def rejected(self, reason):
158
self.logger(u'Client %s was rejected; reason: %s'
159
% (self.properties[u"name"], reason))
266
self.logger('Client %s was rejected; reason: %s'
267
% (self.properties["Name"], reason))
160
268
161
269
def selectable(self):
162
270
"""Make this a "selectable" widget.
163
271
This overrides the method from urwid.FlowWidget."""
164
272
return True
165
273
166
def rows(self, (maxcol,), focus=False):
274
def rows(self, maxcolrow, focus=False):
167
275
"""How many rows this widget will occupy might depend on
168
276
whether we have focus or not.
169
277
This overrides the method from urwid.FlowWidget"""
170
return self.current_widget(focus).rows((maxcol,), focus=focus)
278
return self.current_widget(focus).rows(maxcolrow, focus=focus)
171
279
172
280
def current_widget(self, focus=False):
173
281
if focus or self.opened:
177
285
def update(self):
178
286
"Called when what is visible on the screen should be updated."
179
287
# How to add standout mode to a style
180
with_standout = { u"normal": u"standout",
181
u"bold": u"bold-standout",
182
u"underline-blink":
183
u"underline-blink-standout",
184
u"bold-underline-blink":
185
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",
186
294
}
187
295
188
296
# Rebuild focus and non-focus widgets using current properties
189
self._text = (u'%(name)s: %(enabled)s'
190
% { u"name": self.properties[u"name"],
191
u"enabled":
192
(u"enabled"
193
if self.properties[u"enabled"]
194
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
195
335
if not urwid.supports_unicode():
196
336
self._text = self._text.encode("ascii", "replace")
197
textlist = [(u"normal", self._text)]
337
textlist = [("normal", self._text)]
198
338
self._text_widget.set_text(textlist)
199
339
self._focus_text_widget.set_text([(with_standout[text[0]],
200
340
text[1])
208
348
if self.update_hook is not None:
209
349
self.update_hook()
210
350
211
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 = ()
212
364
if self.delete_hook is not None:
213
365
self.delete_hook(self)
366
return super(MandosClientWidget, self).delete(*args, **kwargs)
214
367
215
def render(self, (maxcol,), focus=False):
368
def render(self, maxcolrow, focus=False):
216
369
"""Render differently if we have focus.
217
370
This overrides the method from urwid.FlowWidget"""
218
return self.current_widget(focus).render((maxcol,),
371
return self.current_widget(focus).render(maxcolrow,
219
372
focus=focus)
220
373
221
def keypress(self, (maxcol,), key):
374
def keypress(self, maxcolrow, key):
222
375
"""Handle keys.
223
376
This overrides the method from urwid.FlowWidget"""
224
if key == u"e" or key == u"+":
225
self.proxy.Enable()
226
elif key == u"d" or key == u"-":
227
self.proxy.Disable()
228
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":
229
392
self.server_proxy_object.RemoveClient(self.proxy
230
.object_path)
231
elif key == u"s":
232
self.proxy.StartChecker()
233
elif key == u"S":
234
self.proxy.StopChecker()
235
elif key == u"C":
236
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)
237
404
# xxx
238
# elif key == u"p" or key == "=":
405
# elif key == "p" or key == "=":
239
406
# self.proxy.pause()
240
# elif key == u"u" or key == ":":
407
# elif key == "u" or key == ":":
241
408
# self.proxy.unpause()
242
# elif key == u"RET":
409
# elif key == "RET":
243
410
# self.open()
244
elif key == u"+":
245
self.proxy.Approve(True)
246
elif key == u"-":
247
self.proxy.Approve(False)
248
411
else:
249
412
return key
250
413
265
428
"down" key presses, thus not allowing any containing widgets to
266
429
use them as an excuse to shift focus away from this widget.
267
430
"""
268
def keypress(self, (maxcol, maxrow), key):
269
ret = super(ConstrainedListBox, self).keypress((maxcol, maxrow), key)
270
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"):
271
434
return
272
435
return ret
273
436
282
445
self.screen = urwid.curses_display.Screen()
283
446
284
447
self.screen.register_palette((
285
(u"normal",
286
u"default", u"default", None),
287
(u"bold",
288
u"default", u"default", u"bold"),
289
(u"underline-blink",
290
u"default", u"default", u"underline"),
291
(u"standout",
292
u"default", u"default", u"standout"),
293
(u"bold-underline-blink",
294
u"default", u"default", (u"bold", u"underline")),
295
(u"bold-standout",
296
u"default", u"default", (u"bold", u"standout")),
297
(u"underline-blink-standout",
298
u"default", u"default", (u"underline", u"standout")),
299
(u"bold-underline-blink-standout",
300
u"default", u"default", (u"bold", u"underline",
301
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")),
302
465
))
303
466
304
467
if urwid.supports_unicode():
305
self.divider = u"─" # \u2500
306
#self.divider = u"━" # \u2501
468
self.divider = "─" # \u2500
469
#self.divider = "━" # \u2501
307
470
else:
308
#self.divider = u"-" # \u002d
309
self.divider = u"_" # \u005f
471
#self.divider = "-" # \u002d
472
self.divider = "_" # \u005f
310
473
311
474
self.screen.start()
312
475
326
489
# This keeps track of whether self.uilist currently has
327
490
# self.logbox in it or not
328
491
self.log_visible = True
329
self.log_wrap = u"any"
492
self.log_wrap = "any"
330
493
331
494
self.rebuild()
332
self.log_message_raw((u"bold",
333
u"Mandos Monitor version " + version))
334
self.log_message_raw((u"bold",
335
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"))
336
499
337
500
self.busname = domain + '.Mandos'
338
501
self.main_loop = gobject.MainLoop()
339
self.bus = dbus.SystemBus()
340
mandos_dbus_objc = self.bus.get_object(
341
self.busname, u"/", follow_name_owner_changes=True)
342
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
343
dbus_interface
344
= server_interface)
345
try:
346
mandos_clients = (self.mandos_serv
347
.GetAllClientsWithProperties())
348
except dbus.exceptions.DBusException:
349
mandos_clients = dbus.Dictionary()
350
351
(self.mandos_serv
352
.connect_to_signal(u"ClientRemoved",
353
self.find_and_remove_client,
354
dbus_interface=server_interface,
355
byte_arrays=True))
356
(self.mandos_serv
357
.connect_to_signal(u"ClientAdded",
358
self.add_new_client,
359
dbus_interface=server_interface,
360
byte_arrays=True))
361
(self.mandos_serv
362
.connect_to_signal(u"ClientNotFound",
363
self.client_not_found,
364
dbus_interface=server_interface,
365
byte_arrays=True))
366
for path, client in mandos_clients.iteritems():
367
client_proxy_object = self.bus.get_object(self.busname,
368
path)
369
self.add_client(MandosClientWidget(server_proxy_object
370
=self.mandos_serv,
371
proxy_object
372
=client_proxy_object,
373
properties=client,
374
update_hook
375
=self.refresh,
376
delete_hook
377
=self.remove_client,
378
logger
379
=self.log_message),
380
path=path)
381
502
382
503
def client_not_found(self, fingerprint, address):
383
self.log_message((u"Client with address %s and fingerprint %s"
384
u" could not be found" % (address,
504
self.log_message(("Client with address %s and fingerprint %s"
505
" could not be found" % (address,
385
506
fingerprint)))
386
507
387
508
def rebuild(self):
389
510
Call this when the widget layout needs to change"""
390
511
self.uilist = []
391
512
#self.uilist.append(urwid.ListBox(self.clients))
392
self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),
513
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
514
clients),
393
515
#header=urwid.Divider(),
394
516
header=None,
395
footer=urwid.Divider(div_char=self.divider)))
517
footer=
518
urwid.Divider(div_char=
519
self.divider)))
396
520
if self.log_visible:
397
521
self.uilist.append(self.logbox)
398
pass
399
522
self.topwidget = urwid.Pile(self.uilist)
400
523
401
524
def log_message(self, message):
402
525
timestamp = datetime.datetime.now().isoformat()
403
self.log_message_raw(timestamp + u": " + message)
526
self.log_message_raw(timestamp + ": " + message)
404
527
405
528
def log_message_raw(self, markup):
406
529
"""Add a log message to the log buffer."""
409
532
and len(self.log) > self.max_log_length):
410
533
del self.log[0:len(self.log)-self.max_log_length-1]
411
534
self.logbox.set_focus(len(self.logbox.body.contents),
412
coming_from=u"above")
535
coming_from="above")
413
536
self.refresh()
414
537
415
538
def toggle_log_display(self):
416
539
"""Toggle visibility of the log buffer."""
417
540
self.log_visible = not self.log_visible
418
541
self.rebuild()
419
self.log_message(u"Log visibility changed to: "
420
+ unicode(self.log_visible))
542
#self.log_message("Log visibility changed to: "
543
# + unicode(self.log_visible))
421
544
422
545
def change_log_display(self):
423
546
"""Change type of log display.
424
547
Currently, this toggles wrapping of text lines."""
425
if self.log_wrap == u"clip":
426
self.log_wrap = u"any"
548
if self.log_wrap == "clip":
549
self.log_wrap = "any"
427
550
else:
428
self.log_wrap = u"clip"
551
self.log_wrap = "clip"
429
552
for textwidget in self.log:
430
553
textwidget.set_wrap_mode(self.log_wrap)
431
self.log_message(u"Wrap mode: " + self.log_wrap)
554
#self.log_message("Wrap mode: " + self.log_wrap)
432
555
433
556
def find_and_remove_client(self, path, name):
434
"""Find an client from its object path and remove it.
557
"""Find a client by its object path and remove it.
435
558
436
559
This is connected to the ClientRemoved signal from the
437
560
Mandos server object."""
439
562
client = self.clients_dict[path]
440
563
except KeyError:
441
564
# not found?
565
self.log_message("Unknown client %r (%r) removed", name,
566
path)
442
567
return
443
self.remove_client(client, path)
568
client.delete()
444
569
445
570
def add_new_client(self, path):
446
571
client_proxy_object = self.bus.get_object(self.busname, path)
461
586
if path is None:
462
587
path = client.proxy.object_path
463
588
self.clients_dict[path] = client
464
self.clients.sort(None, lambda c: c.properties[u"name"])
589
self.clients.sort(None, lambda c: c.properties["Name"])
465
590
self.refresh()
466
591
467
592
def remove_client(self, client, path=None):
483
608
484
609
def run(self):
485
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
486
654
self.refresh()
487
655
self._input_callback_tag = (gobject.io_add_watch
488
656
(sys.stdin.fileno(),
498
666
499
667
def process_input(self, source, condition):
500
668
keys = self.screen.get_input()
501
translations = { u"ctrl n": u"down", # Emacs
502
u"ctrl p": u"up", # Emacs
503
u"ctrl v": u"page down", # Emacs
504
u"meta v": u"page up", # Emacs
505
u" ": u"page down", # less
506
u"f": u"page down", # less
507
u"b": u"page up", # less
508
u"j": u"down", # vi
509
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
510
678
}
511
679
for key in keys:
512
680
try:
514
682
except KeyError: # :-)
515
683
pass
516
684
517
if key == u"q" or key == u"Q":
685
if key == "q" or key == "Q":
518
686
self.stop()
519
687
break
520
elif key == u"window resize":
688
elif key == "window resize":
521
689
self.size = self.screen.get_cols_rows()
522
690
self.refresh()
523
elif key == u"\f": # Ctrl-L
691
elif key == "\f": # Ctrl-L
524
692
self.refresh()
525
elif key == u"l" or key == u"D":
693
elif key == "l" or key == "D":
526
694
self.toggle_log_display()
527
695
self.refresh()
528
elif key == u"w" or key == u"i":
696
elif key == "w" or key == "i":
529
697
self.change_log_display()
530
698
self.refresh()
531
elif key == u"?" or key == u"f1" or key == u"esc":
699
elif key == "?" or key == "f1" or key == "esc":
532
700
if not self.log_visible:
533
701
self.log_visible = True
534
702
self.rebuild()
535
self.log_message_raw((u"bold",
536
u" ".
537
join((u"q: Quit",
538
u"?: Help",
539
u"l: Log window toggle",
540
u"TAB: Switch window",
541
u"w: Wrap (log)"))))
542
self.log_message_raw((u"bold",
543
u" "
544
.join((u"Clients:",
545
u"e: Enable",
546
u"d: Disable",
547
u"r: Remove",
548
u"s: Start new checker",
549
u"S: Stop checker",
550
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"))))
551
721
self.refresh()
552
elif key == u"tab":
722
elif key == "tab":
553
723
if self.topwidget.get_focus() is self.logbox:
554
724
self.topwidget.set_focus(0)
555
725
else:
556
726
self.topwidget.set_focus(self.logbox)
557
727
self.refresh()
558
#elif (key == u"end" or key == u"meta >" or key == u"G"
559
# or key == u">"):
728
#elif (key == "end" or key == "meta >" or key == "G"
729
# or key == ">"):
560
730
# pass # xxx end-of-buffer
561
#elif (key == u"home" or key == u"meta <" or key == u"g"
562
# or key == u"<"):
731
#elif (key == "home" or key == "meta <" or key == "g"
732
# or key == "<"):
563
733
# pass # xxx beginning-of-buffer
564
#elif key == u"ctrl e" or key == u"$":
734
#elif key == "ctrl e" or key == "$":
565
735
# pass # xxx move-end-of-line
566
#elif key == u"ctrl a" or key == u"^":
736
#elif key == "ctrl a" or key == "^":
567
737
# pass # xxx move-beginning-of-line
568
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
738
#elif key == "ctrl b" or key == "meta (" or key == "h":
569
739
# pass # xxx left
570
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
740
#elif key == "ctrl f" or key == "meta )" or key == "l":
571
741
# pass # xxx right
572
#elif key == u"a":
742
#elif key == "a":
573
743
# pass # scroll up log
574
#elif key == u"z":
744
#elif key == "z":
575
745
# pass # scroll down log
576
746
elif self.topwidget.selectable():
577
747
self.topwidget.keypress(self.size, key)
581
751
ui = UserInterface()
582
752
try:
583
753
ui.run()
754
except KeyboardInterrupt:
755
ui.screen.stop()
584
756
except Exception, e:
585
757
ui.log_message(unicode(e))
586
758
ui.screen.stop()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0