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