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 419
- compare with another revision
- download diff
- download tarball
- view history from revision 419
- Committer: teddy at bsnet
- Date: 2010-09-09 18:16:14 UTC
- mfrom: (237.2.35 mandos-empty-device)
- Revision ID: teddy@fukt.bsnet.se-20100909181614-oanlmvkzsiodbo3c
Merge in branch to interpret an empty device name to mean
"autodetect".
"autodetect".
- files removed:
- 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
#
24
3
25
from __future__ import (division, absolute_import, print_function,
26
unicode_literals)
4
from __future__ import division, absolute_import, with_statement
27
5
28
6
import sys
29
7
import os
43
21
44
22
import locale
45
23
46
locale.setlocale(locale.LC_ALL, '')
47
48
import logging
49
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
24
locale.setlocale(locale.LC_ALL, u'')
50
25
51
26
# Some useful constants
52
domain = 'se.recompile'
27
domain = 'se.bsnet.fukt'
53
28
server_interface = domain + '.Mandos'
54
29
client_interface = domain + '.Mandos.Client'
55
version = "1.5.3"
30
version = "1.0.14"
56
31
57
32
# Always run in monochrome mode
58
33
urwid.curses_display.curses.has_colors = lambda : False
66
41
"Parse an ISO 8601 date string to a datetime.datetime()"
67
42
if not iso:
68
43
return None
69
d, t = iso.split("T", 1)
70
year, month, day = d.split("-", 2)
71
hour, minute, second = t.split(":", 2)
44
d, t = iso.split(u"T", 1)
45
year, month, day = d.split(u"-", 2)
46
hour, minute, second = t.split(u":", 2)
72
47
second, fraction = divmod(float(second), 1)
73
48
return datetime.datetime(int(year),
74
49
int(month),
87
62
self.proxy = proxy_object # Mandos Client proxy object
88
63
89
64
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))
65
self.proxy.connect_to_signal(u"PropertyChanged",
66
self.property_changed,
67
client_interface,
68
byte_arrays=True)
95
69
96
70
self.properties.update(
97
71
self.proxy.GetAll(client_interface,
98
72
dbus_interface = dbus.PROPERTIES_IFACE))
99
100
#XXX This breaks good super behaviour
101
# super(MandosClientPropertyCache, self).__init__(
102
# *args, **kwargs)
73
super(MandosClientPropertyCache, self).__init__(
74
proxy_object=proxy_object, *args, **kwargs)
103
75
104
76
def property_changed(self, property=None, value=None):
105
77
"""This is called whenever we get a PropertyChanged signal
107
79
"""
108
80
# Update properties dict with new value
109
81
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)
115
82
116
83
117
84
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
130
97
self.logger = logger
131
98
132
99
self._update_timer_callback_tag = None
133
self._update_timer_callback_lock = 0
100
self.last_checker_failed = False
134
101
135
102
# The widget shown normally
136
self._text_widget = urwid.Text("")
103
self._text_widget = urwid.Text(u"")
137
104
# The widget shown when we have focus
138
self._focus_text_widget = urwid.Text("")
105
self._focus_text_widget = urwid.Text(u"")
139
106
super(MandosClientWidget, self).__init__(
140
107
update_hook=update_hook, delete_hook=delete_hook,
141
108
*args, **kwargs)
142
109
self.update()
143
110
self.opened = False
144
111
self.proxy.connect_to_signal(u"CheckerCompleted",
112
self.checker_completed,
113
client_interface,
114
byte_arrays=True)
115
self.proxy.connect_to_signal(u"CheckerStarted",
116
self.checker_started,
117
client_interface,
118
byte_arrays=True)
119
self.proxy.connect_to_signal(u"GotSecret",
120
self.got_secret,
121
client_interface,
122
byte_arrays=True)
123
self.proxy.connect_to_signal(u"Rejected",
124
self.rejected,
125
client_interface,
126
byte_arrays=True)
145
127
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
154
self.match_objects = (
155
self.proxy.connect_to_signal("CheckerCompleted",
156
self.checker_completed,
157
client_interface,
158
byte_arrays=True),
159
self.proxy.connect_to_signal("CheckerStarted",
160
self.checker_started,
161
client_interface,
162
byte_arrays=True),
163
self.proxy.connect_to_signal("GotSecret",
164
self.got_secret,
165
client_interface,
166
byte_arrays=True),
167
self.proxy.connect_to_signal("NeedApproval",
168
self.need_approval,
169
client_interface,
170
byte_arrays=True),
171
self.proxy.connect_to_signal("Rejected",
172
self.rejected,
173
client_interface,
174
byte_arrays=True))
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))
187
188
def using_timer(self, flag):
189
"""Call this method with True or False when timer should be
190
activated or deactivated.
191
"""
192
old = self._update_timer_callback_lock
193
if flag:
194
self._update_timer_callback_lock += 1
128
["last_checked_ok"])
129
if last_checked_ok is None:
130
self.last_checker_failed = True
195
131
else:
196
self._update_timer_callback_lock -= 1
197
if old == 0 and self._update_timer_callback_lock:
198
# Will update the shown timer value every second
132
self.last_checker_failed = ((datetime.datetime.utcnow()
133
- last_checked_ok)
134
> datetime.timedelta
135
(milliseconds=
136
self.properties["interval"]))
137
if self.last_checker_failed:
199
138
self._update_timer_callback_tag = (gobject.timeout_add
200
139
(1000,
201
140
self.update_timer))
202
elif old and self._update_timer_callback_lock == 0:
203
gobject.source_remove(self._update_timer_callback_tag)
204
self._update_timer_callback_tag = None
205
141
206
142
def checker_completed(self, exitstatus, condition, command):
207
143
if exitstatus == 0:
144
if self.last_checker_failed:
145
self.last_checker_failed = False
146
gobject.source_remove(self._update_timer_callback_tag)
147
self._update_timer_callback_tag = None
148
self.logger(u'Checker for client %s (command "%s")'
149
u' was successful'
150
% (self.properties[u"name"], command))
208
151
self.update()
209
152
return
210
153
# Checker failed
154
if not self.last_checker_failed:
155
self.last_checker_failed = True
156
self._update_timer_callback_tag = (gobject.timeout_add
157
(1000,
158
self.update_timer))
211
159
if os.WIFEXITED(condition):
212
self.logger('Checker for client %s (command "%s")'
213
' failed with exit code %s'
214
% (self.properties["Name"], command,
160
self.logger(u'Checker for client %s (command "%s")'
161
u' failed with exit code %s'
162
% (self.properties[u"name"], command,
215
163
os.WEXITSTATUS(condition)))
216
164
elif os.WIFSIGNALED(condition):
217
self.logger('Checker for client %s (command "%s")'
218
' was killed by signal %s'
219
% (self.properties["Name"], command,
165
self.logger(u'Checker for client %s (command "%s")'
166
u' was killed by signal %s'
167
% (self.properties[u"name"], command,
220
168
os.WTERMSIG(condition)))
221
169
elif os.WCOREDUMP(condition):
222
self.logger('Checker for client %s (command "%s")'
223
' dumped core'
224
% (self.properties["Name"], command))
170
self.logger(u'Checker for client %s (command "%s")'
171
u' dumped core'
172
% (self.properties[u"name"], command))
225
173
else:
226
self.logger('Checker for client %s completed'
227
' mysteriously')
174
self.logger(u'Checker for client %s completed mysteriously')
228
175
self.update()
229
176
230
177
def checker_started(self, command):
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
178
self.logger(u'Client %s started checker "%s"'
179
% (self.properties[u"name"], unicode(command)))
236
180
237
181
def got_secret(self):
238
self.logger('Client %s received its secret'
239
% self.properties["Name"])
240
241
def need_approval(self, timeout, default):
242
if not default:
243
message = 'Client %s needs approval within %s seconds'
244
else:
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)
249
250
def rejected(self, reason):
251
self.logger('Client %s was rejected; reason: %s'
252
% (self.properties["Name"], reason))
182
self.logger(u'Client %s received its secret'
183
% self.properties[u"name"])
184
185
def rejected(self):
186
self.logger(u'Client %s was rejected'
187
% self.properties[u"name"])
253
188
254
189
def selectable(self):
255
190
"""Make this a "selectable" widget.
256
191
This overrides the method from urwid.FlowWidget."""
257
192
return True
258
193
259
def rows(self, maxcolrow, focus=False):
194
def rows(self, (maxcol,), focus=False):
260
195
"""How many rows this widget will occupy might depend on
261
196
whether we have focus or not.
262
197
This overrides the method from urwid.FlowWidget"""
263
return self.current_widget(focus).rows(maxcolrow, focus=focus)
198
return self.current_widget(focus).rows((maxcol,), focus=focus)
264
199
265
200
def current_widget(self, focus=False):
266
201
if focus or self.opened:
270
205
def update(self):
271
206
"Called when what is visible on the screen should be updated."
272
207
# How to add standout mode to a style
273
with_standout = { "normal": "standout",
274
"bold": "bold-standout",
275
"underline-blink":
276
"underline-blink-standout",
277
"bold-underline-blink":
278
"bold-underline-blink-standout",
208
with_standout = { u"normal": u"standout",
209
u"bold": u"bold-standout",
210
u"underline-blink":
211
u"underline-blink-standout",
212
u"bold-underline-blink":
213
u"bold-underline-blink-standout",
279
214
}
280
215
281
216
# Rebuild focus and non-focus widgets using current properties
282
283
# Base part of a client. Name!
284
base = ('%(name)s: '
285
% {"name": self.properties["Name"]})
286
if not self.properties["Enabled"]:
287
message = "DISABLED"
288
elif self.properties["ApprovalPending"]:
289
timeout = datetime.timedelta(milliseconds
290
= self.properties
291
["ApprovalDelay"])
292
last_approval_request = isoformat_to_datetime(
293
self.properties["LastApprovalRequest"])
294
if last_approval_request is not None:
295
timer = timeout - (datetime.datetime.utcnow()
296
- last_approval_request)
297
else:
298
timer = datetime.timedelta()
299
if self.properties["ApprovedByDefault"]:
300
message = "Approval in %s. (d)eny?"
301
else:
302
message = "Denial in %s. (a)pprove?"
303
message = message % unicode(timer).rsplit(".", 1)[0]
304
elif self.properties["LastCheckerStatus"] != 0:
305
# When checker has failed, print a timer until client expires
306
expires = self.properties["Expires"]
307
if expires == "":
308
timer = datetime.timedelta(0)
309
else:
310
expires = datetime.datetime.strptime(expires,
311
'%Y-%m-%dT%H:%M:%S.%f')
312
timer = expires - datetime.datetime.utcnow()
313
message = ('A checker has failed! Time until client'
314
' gets disabled: %s'
315
% unicode(timer).rsplit(".", 1)[0])
316
else:
317
message = "enabled"
318
self._text = "%s%s" % (base, message)
319
217
self._text = (u'%(name)s: %(enabled)s%(timer)s'
218
% { u"name": self.properties[u"name"],
219
u"enabled":
220
(u"enabled"
221
if self.properties[u"enabled"]
222
else u"DISABLED"),
223
u"timer": (unicode(datetime.timedelta
224
(milliseconds =
225
self.properties
226
[u"timeout"])
227
- (datetime.datetime
228
.utcnow()
229
- isoformat_to_datetime
230
(max((self.properties
231
["last_checked_ok"]
232
or
233
self.properties
234
["created"]),
235
self.properties[u"last_enabled"]))))
236
if (self.last_checker_failed
237
and self.properties
238
[u"enabled"])
239
else u"")})
320
240
if not urwid.supports_unicode():
321
241
self._text = self._text.encode("ascii", "replace")
322
textlist = [("normal", self._text)]
242
textlist = [(u"normal", self._text)]
323
243
self._text_widget.set_text(textlist)
324
244
self._focus_text_widget.set_text([(with_standout[text[0]],
325
245
text[1])
334
254
self.update_hook()
335
255
336
256
def update_timer(self):
337
"""called by gobject. Will indefinitely loop until
338
gobject.source_remove() on tag is called"""
257
"called by gobject"
339
258
self.update()
340
259
return True # Keep calling this
341
260
342
def delete(self, *args, **kwargs):
261
def delete(self):
343
262
if self._update_timer_callback_tag is not None:
344
263
gobject.source_remove(self._update_timer_callback_tag)
345
264
self._update_timer_callback_tag = None
346
for match in self.match_objects:
347
match.remove()
348
self.match_objects = ()
349
265
if self.delete_hook is not None:
350
266
self.delete_hook(self)
351
return super(MandosClientWidget, self).delete(*args, **kwargs)
352
267
353
def render(self, maxcolrow, focus=False):
268
def render(self, (maxcol,), focus=False):
354
269
"""Render differently if we have focus.
355
270
This overrides the method from urwid.FlowWidget"""
356
return self.current_widget(focus).render(maxcolrow,
271
return self.current_widget(focus).render((maxcol,),
357
272
focus=focus)
358
273
359
def keypress(self, maxcolrow, key):
274
def keypress(self, (maxcol,), key):
360
275
"""Handle keys.
361
276
This overrides the method from urwid.FlowWidget"""
362
if key == "+":
363
self.proxy.Enable(dbus_interface = client_interface,
364
ignore_reply=True)
365
elif key == "-":
366
self.proxy.Disable(dbus_interface = client_interface,
367
ignore_reply=True)
368
elif key == "a":
369
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
370
dbus_interface = client_interface,
371
ignore_reply=True)
372
elif key == "d":
373
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
374
dbus_interface = client_interface,
375
ignore_reply=True)
376
elif key == "R" or key == "_" or key == "ctrl k":
277
if key == u"e" or key == u"+":
278
self.proxy.Enable()
279
elif key == u"d" or key == u"-":
280
self.proxy.Disable()
281
elif key == u"r" or key == u"_" or key == u"ctrl k":
377
282
self.server_proxy_object.RemoveClient(self.proxy
378
.object_path,
379
ignore_reply=True)
380
elif key == "s":
381
self.proxy.StartChecker(dbus_interface = client_interface,
382
ignore_reply=True)
383
elif key == "S":
384
self.proxy.StopChecker(dbus_interface = client_interface,
385
ignore_reply=True)
386
elif key == "C":
387
self.proxy.CheckedOK(dbus_interface = client_interface,
388
ignore_reply=True)
283
.object_path)
284
elif key == u"s":
285
self.proxy.StartChecker()
286
elif key == u"S":
287
self.proxy.StopChecker()
288
elif key == u"C":
289
self.proxy.CheckedOK()
389
290
# xxx
390
# elif key == "p" or key == "=":
291
# elif key == u"p" or key == "=":
391
292
# self.proxy.pause()
392
# elif key == "u" or key == ":":
293
# elif key == u"u" or key == ":":
393
294
# self.proxy.unpause()
394
# elif key == "RET":
295
# elif key == u"RET":
395
296
# self.open()
396
297
else:
397
298
return key
413
314
"down" key presses, thus not allowing any containing widgets to
414
315
use them as an excuse to shift focus away from this widget.
415
316
"""
416
def keypress(self, maxcolrow, key):
417
ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)
418
if ret in ("up", "down"):
317
def keypress(self, (maxcol, maxrow), key):
318
ret = super(ConstrainedListBox, self).keypress((maxcol, maxrow), key)
319
if ret in (u"up", u"down"):
419
320
return
420
321
return ret
421
322
430
331
self.screen = urwid.curses_display.Screen()
431
332
432
333
self.screen.register_palette((
433
("normal",
434
"default", "default", None),
435
("bold",
436
"default", "default", "bold"),
437
("underline-blink",
438
"default", "default", "underline"),
439
("standout",
440
"default", "default", "standout"),
441
("bold-underline-blink",
442
"default", "default", ("bold", "underline")),
443
("bold-standout",
444
"default", "default", ("bold", "standout")),
445
("underline-blink-standout",
446
"default", "default", ("underline", "standout")),
447
("bold-underline-blink-standout",
448
"default", "default", ("bold", "underline",
449
"standout")),
334
(u"normal",
335
u"default", u"default", None),
336
(u"bold",
337
u"default", u"default", u"bold"),
338
(u"underline-blink",
339
u"default", u"default", u"underline"),
340
(u"standout",
341
u"default", u"default", u"standout"),
342
(u"bold-underline-blink",
343
u"default", u"default", (u"bold", u"underline")),
344
(u"bold-standout",
345
u"default", u"default", (u"bold", u"standout")),
346
(u"underline-blink-standout",
347
u"default", u"default", (u"underline", u"standout")),
348
(u"bold-underline-blink-standout",
349
u"default", u"default", (u"bold", u"underline",
350
u"standout")),
450
351
))
451
352
452
353
if urwid.supports_unicode():
453
self.divider = "─" # \u2500
454
#self.divider = "━" # \u2501
354
self.divider = u"─" # \u2500
355
#self.divider = u"━" # \u2501
455
356
else:
456
#self.divider = "-" # \u002d
457
self.divider = "_" # \u005f
357
#self.divider = u"-" # \u002d
358
self.divider = u"_" # \u005f
458
359
459
360
self.screen.start()
460
361
474
375
# This keeps track of whether self.uilist currently has
475
376
# self.logbox in it or not
476
377
self.log_visible = True
477
self.log_wrap = "any"
378
self.log_wrap = u"any"
478
379
479
380
self.rebuild()
480
self.log_message_raw(("bold",
481
"Mandos Monitor version " + version))
482
self.log_message_raw(("bold",
483
"q: Quit ?: Help"))
381
self.log_message_raw((u"bold",
382
u"Mandos Monitor version " + version))
383
self.log_message_raw((u"bold",
384
u"q: Quit ?: Help"))
484
385
485
386
self.busname = domain + '.Mandos'
486
387
self.main_loop = gobject.MainLoop()
388
self.bus = dbus.SystemBus()
389
mandos_dbus_objc = self.bus.get_object(
390
self.busname, u"/", follow_name_owner_changes=True)
391
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
392
dbus_interface
393
= server_interface)
394
try:
395
mandos_clients = (self.mandos_serv
396
.GetAllClientsWithProperties())
397
except dbus.exceptions.DBusException:
398
mandos_clients = dbus.Dictionary()
399
400
(self.mandos_serv
401
.connect_to_signal(u"ClientRemoved",
402
self.find_and_remove_client,
403
dbus_interface=server_interface,
404
byte_arrays=True))
405
(self.mandos_serv
406
.connect_to_signal(u"ClientAdded",
407
self.add_new_client,
408
dbus_interface=server_interface,
409
byte_arrays=True))
410
(self.mandos_serv
411
.connect_to_signal(u"ClientNotFound",
412
self.client_not_found,
413
dbus_interface=server_interface,
414
byte_arrays=True))
415
for path, client in mandos_clients.iteritems():
416
client_proxy_object = self.bus.get_object(self.busname,
417
path)
418
self.add_client(MandosClientWidget(server_proxy_object
419
=self.mandos_serv,
420
proxy_object
421
=client_proxy_object,
422
properties=client,
423
update_hook
424
=self.refresh,
425
delete_hook
426
=self.remove_client,
427
logger
428
=self.log_message),
429
path=path)
487
430
488
431
def client_not_found(self, fingerprint, address):
489
self.log_message(("Client with address %s and fingerprint %s"
490
" could not be found" % (address,
432
self.log_message((u"Client with address %s and fingerprint %s"
433
u" could not be found" % (address,
491
434
fingerprint)))
492
435
493
436
def rebuild(self):
495
438
Call this when the widget layout needs to change"""
496
439
self.uilist = []
497
440
#self.uilist.append(urwid.ListBox(self.clients))
498
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
499
clients),
441
self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),
500
442
#header=urwid.Divider(),
501
443
header=None,
502
footer=
503
urwid.Divider(div_char=
504
self.divider)))
444
footer=urwid.Divider(div_char=self.divider)))
505
445
if self.log_visible:
506
446
self.uilist.append(self.logbox)
447
pass
507
448
self.topwidget = urwid.Pile(self.uilist)
508
449
509
450
def log_message(self, message):
510
451
timestamp = datetime.datetime.now().isoformat()
511
self.log_message_raw(timestamp + ": " + message)
452
self.log_message_raw(timestamp + u": " + message)
512
453
513
454
def log_message_raw(self, markup):
514
455
"""Add a log message to the log buffer."""
517
458
and len(self.log) > self.max_log_length):
518
459
del self.log[0:len(self.log)-self.max_log_length-1]
519
460
self.logbox.set_focus(len(self.logbox.body.contents),
520
coming_from="above")
461
coming_from=u"above")
521
462
self.refresh()
522
463
523
464
def toggle_log_display(self):
524
465
"""Toggle visibility of the log buffer."""
525
466
self.log_visible = not self.log_visible
526
467
self.rebuild()
527
#self.log_message("Log visibility changed to: "
528
# + unicode(self.log_visible))
468
self.log_message(u"Log visibility changed to: "
469
+ unicode(self.log_visible))
529
470
530
471
def change_log_display(self):
531
472
"""Change type of log display.
532
473
Currently, this toggles wrapping of text lines."""
533
if self.log_wrap == "clip":
534
self.log_wrap = "any"
474
if self.log_wrap == u"clip":
475
self.log_wrap = u"any"
535
476
else:
536
self.log_wrap = "clip"
477
self.log_wrap = u"clip"
537
478
for textwidget in self.log:
538
479
textwidget.set_wrap_mode(self.log_wrap)
539
#self.log_message("Wrap mode: " + self.log_wrap)
480
self.log_message(u"Wrap mode: " + self.log_wrap)
540
481
541
482
def find_and_remove_client(self, path, name):
542
"""Find a client by its object path and remove it.
483
"""Find an client from its object path and remove it.
543
484
544
485
This is connected to the ClientRemoved signal from the
545
486
Mandos server object."""
547
488
client = self.clients_dict[path]
548
489
except KeyError:
549
490
# not found?
550
self.log_message("Unknown client %r (%r) removed", name,
551
path)
552
491
return
553
client.delete()
492
self.remove_client(client, path)
554
493
555
494
def add_new_client(self, path):
556
495
client_proxy_object = self.bus.get_object(self.busname, path)
571
510
if path is None:
572
511
path = client.proxy.object_path
573
512
self.clients_dict[path] = client
574
self.clients.sort(None, lambda c: c.properties["Name"])
513
self.clients.sort(None, lambda c: c.properties[u"name"])
575
514
self.refresh()
576
515
577
516
def remove_client(self, client, path=None):
593
532
594
533
def run(self):
595
534
"""Start the main loop and exit when it's done."""
596
self.bus = dbus.SystemBus()
597
mandos_dbus_objc = self.bus.get_object(
598
self.busname, "/", follow_name_owner_changes=True)
599
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
600
dbus_interface
601
= server_interface)
602
try:
603
mandos_clients = (self.mandos_serv
604
.GetAllClientsWithProperties())
605
except dbus.exceptions.DBusException:
606
mandos_clients = dbus.Dictionary()
607
608
(self.mandos_serv
609
.connect_to_signal("ClientRemoved",
610
self.find_and_remove_client,
611
dbus_interface=server_interface,
612
byte_arrays=True))
613
(self.mandos_serv
614
.connect_to_signal("ClientAdded",
615
self.add_new_client,
616
dbus_interface=server_interface,
617
byte_arrays=True))
618
(self.mandos_serv
619
.connect_to_signal("ClientNotFound",
620
self.client_not_found,
621
dbus_interface=server_interface,
622
byte_arrays=True))
623
for path, client in mandos_clients.iteritems():
624
client_proxy_object = self.bus.get_object(self.busname,
625
path)
626
self.add_client(MandosClientWidget(server_proxy_object
627
=self.mandos_serv,
628
proxy_object
629
=client_proxy_object,
630
properties=client,
631
update_hook
632
=self.refresh,
633
delete_hook
634
=self.remove_client,
635
logger
636
=self.log_message),
637
path=path)
638
639
535
self.refresh()
640
536
self._input_callback_tag = (gobject.io_add_watch
641
537
(sys.stdin.fileno(),
651
547
652
548
def process_input(self, source, condition):
653
549
keys = self.screen.get_input()
654
translations = { "ctrl n": "down", # Emacs
655
"ctrl p": "up", # Emacs
656
"ctrl v": "page down", # Emacs
657
"meta v": "page up", # Emacs
658
" ": "page down", # less
659
"f": "page down", # less
660
"b": "page up", # less
661
"j": "down", # vi
662
"k": "up", # vi
550
translations = { u"ctrl n": u"down", # Emacs
551
u"ctrl p": u"up", # Emacs
552
u"ctrl v": u"page down", # Emacs
553
u"meta v": u"page up", # Emacs
554
u" ": u"page down", # less
555
u"f": u"page down", # less
556
u"b": u"page up", # less
557
u"j": u"down", # vi
558
u"k": u"up", # vi
663
559
}
664
560
for key in keys:
665
561
try:
667
563
except KeyError: # :-)
668
564
pass
669
565
670
if key == "q" or key == "Q":
566
if key == u"q" or key == u"Q":
671
567
self.stop()
672
568
break
673
elif key == "window resize":
569
elif key == u"window resize":
674
570
self.size = self.screen.get_cols_rows()
675
571
self.refresh()
676
elif key == "\f": # Ctrl-L
572
elif key == u"\f": # Ctrl-L
677
573
self.refresh()
678
elif key == "l" or key == "D":
574
elif key == u"l" or key == u"D":
679
575
self.toggle_log_display()
680
576
self.refresh()
681
elif key == "w" or key == "i":
577
elif key == u"w" or key == u"i":
682
578
self.change_log_display()
683
579
self.refresh()
684
elif key == "?" or key == "f1" or key == "esc":
580
elif key == u"?" or key == u"f1" or key == u"esc":
685
581
if not self.log_visible:
686
582
self.log_visible = True
687
583
self.rebuild()
688
self.log_message_raw(("bold",
689
" ".
690
join(("q: Quit",
691
"?: Help",
692
"l: Log window toggle",
693
"TAB: Switch window",
694
"w: Wrap (log)"))))
695
self.log_message_raw(("bold",
696
" "
697
.join(("Clients:",
698
"+: Enable",
699
"-: Disable",
700
"R: Remove",
701
"s: Start new checker",
702
"S: Stop checker",
703
"C: Checker OK",
704
"a: Approve",
705
"d: Deny"))))
584
self.log_message_raw((u"bold",
585
u" ".
586
join((u"q: Quit",
587
u"?: Help",
588
u"l: Log window toggle",
589
u"TAB: Switch window",
590
u"w: Wrap (log)"))))
591
self.log_message_raw((u"bold",
592
u" "
593
.join((u"Clients:",
594
u"e: Enable",
595
u"d: Disable",
596
u"r: Remove",
597
u"s: Start new checker",
598
u"S: Stop checker",
599
u"C: Checker OK"))))
706
600
self.refresh()
707
elif key == "tab":
601
elif key == u"tab":
708
602
if self.topwidget.get_focus() is self.logbox:
709
603
self.topwidget.set_focus(0)
710
604
else:
711
605
self.topwidget.set_focus(self.logbox)
712
606
self.refresh()
713
#elif (key == "end" or key == "meta >" or key == "G"
714
# or key == ">"):
607
#elif (key == u"end" or key == u"meta >" or key == u"G"
608
# or key == u">"):
715
609
# pass # xxx end-of-buffer
716
#elif (key == "home" or key == "meta <" or key == "g"
717
# or key == "<"):
610
#elif (key == u"home" or key == u"meta <" or key == u"g"
611
# or key == u"<"):
718
612
# pass # xxx beginning-of-buffer
719
#elif key == "ctrl e" or key == "$":
613
#elif key == u"ctrl e" or key == u"$":
720
614
# pass # xxx move-end-of-line
721
#elif key == "ctrl a" or key == "^":
615
#elif key == u"ctrl a" or key == u"^":
722
616
# pass # xxx move-beginning-of-line
723
#elif key == "ctrl b" or key == "meta (" or key == "h":
617
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
724
618
# pass # xxx left
725
#elif key == "ctrl f" or key == "meta )" or key == "l":
619
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
726
620
# pass # xxx right
727
#elif key == "a":
621
#elif key == u"a":
728
622
# pass # scroll up log
729
#elif key == "z":
623
#elif key == u"z":
730
624
# pass # scroll down log
731
625
elif self.topwidget.selectable():
732
626
self.topwidget.keypress(self.size, key)
736
630
ui = UserInterface()
737
631
try:
738
632
ui.run()
739
except KeyboardInterrupt:
740
ui.screen.stop()
741
633
except Exception, e:
742
634
ui.log_message(unicode(e))
743
635
ui.screen.stop()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0