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