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