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 614
- compare with another revision
- download diff
- download tarball
- view history from revision 614
- Committer: Teddy Hogeborn
- Date: 2012-10-24 19:34:13 UTC
- Revision ID: teddy@recompile.se-20121024193413-yiorm0x5lj48fu7i
* mandos: Comment changes.
* mandos-keygen (--password): Fix bashism. Thanks to Raphael Geissert
<atomo64@gmail.com> for the bug report.
* mandos-keygen (--password): Fix bashism. Thanks to Raphael Geissert
<atomo64@gmail.com> for the bug report.
- 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):
492
"""Log message formatted with timestamp"""
382
493
timestamp = datetime.datetime.now().isoformat()
383
self.log_message_raw(timestamp + u": " + message)
494
self.log_message_raw(timestamp + ": " + message)
384
495
385
496
def log_message_raw(self, markup):
386
497
"""Add a log message to the log buffer."""
389
500
and len(self.log) > self.max_log_length):
390
501
del self.log[0:len(self.log)-self.max_log_length-1]
391
502
self.logbox.set_focus(len(self.logbox.body.contents),
392
coming_from=u"above")
503
coming_from="above")
393
504
self.refresh()
394
505
395
506
def toggle_log_display(self):
396
507
"""Toggle visibility of the log buffer."""
397
508
self.log_visible = not self.log_visible
398
509
self.rebuild()
399
self.log_message(u"Log visibility changed to: "
400
+ unicode(self.log_visible))
510
#self.log_message("Log visibility changed to: "
511
# + unicode(self.log_visible))
401
512
402
513
def change_log_display(self):
403
514
"""Change type of log display.
404
515
Currently, this toggles wrapping of text lines."""
405
if self.log_wrap == u"clip":
406
self.log_wrap = u"any"
516
if self.log_wrap == "clip":
517
self.log_wrap = "any"
407
518
else:
408
self.log_wrap = u"clip"
519
self.log_wrap = "clip"
409
520
for textwidget in self.log:
410
521
textwidget.set_wrap_mode(self.log_wrap)
411
self.log_message(u"Wrap mode: " + self.log_wrap)
522
#self.log_message("Wrap mode: " + self.log_wrap)
412
523
413
524
def find_and_remove_client(self, path, name):
414
"""Find an client from its object path and remove it.
525
"""Find a client by its object path and remove it.
415
526
416
527
This is connected to the ClientRemoved signal from the
417
528
Mandos server object."""
419
530
client = self.clients_dict[path]
420
531
except KeyError:
421
532
# not found?
533
self.log_message("Unknown client {0!r} ({1!r}) removed"
534
.format(name, path))
422
535
return
423
self.remove_client(client, path)
536
client.delete()
424
537
425
538
def add_new_client(self, path):
426
539
client_proxy_object = self.bus.get_object(self.busname, path)
441
554
if path is None:
442
555
path = client.proxy.object_path
443
556
self.clients_dict[path] = client
444
self.clients.sort(None, lambda c: c.properties[u"name"])
557
self.clients.sort(None, lambda c: c.properties["Name"])
445
558
self.refresh()
446
559
447
560
def remove_client(self, client, path=None):
463
576
464
577
def run(self):
465
578
"""Start the main loop and exit when it's done."""
579
self.bus = dbus.SystemBus()
580
mandos_dbus_objc = self.bus.get_object(
581
self.busname, "/", follow_name_owner_changes=True)
582
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
583
dbus_interface
584
= server_interface)
585
try:
586
mandos_clients = (self.mandos_serv
587
.GetAllClientsWithProperties())
588
if not mandos_clients:
589
self.log_message_raw(("bold", "Note: Server has no clients."))
590
except dbus.exceptions.DBusException:
591
self.log_message_raw(("bold", "Note: No Mandos servers running."))
592
mandos_clients = dbus.Dictionary()
593
594
(self.mandos_serv
595
.connect_to_signal("ClientRemoved",
596
self.find_and_remove_client,
597
dbus_interface=server_interface,
598
byte_arrays=True))
599
(self.mandos_serv
600
.connect_to_signal("ClientAdded",
601
self.add_new_client,
602
dbus_interface=server_interface,
603
byte_arrays=True))
604
(self.mandos_serv
605
.connect_to_signal("ClientNotFound",
606
self.client_not_found,
607
dbus_interface=server_interface,
608
byte_arrays=True))
609
for path, client in mandos_clients.iteritems():
610
client_proxy_object = self.bus.get_object(self.busname,
611
path)
612
self.add_client(MandosClientWidget(server_proxy_object
613
=self.mandos_serv,
614
proxy_object
615
=client_proxy_object,
616
properties=client,
617
update_hook
618
=self.refresh,
619
delete_hook
620
=self.remove_client,
621
logger
622
=self.log_message),
623
path=path)
624
466
625
self.refresh()
467
626
self._input_callback_tag = (gobject.io_add_watch
468
627
(sys.stdin.fileno(),
478
637
479
638
def process_input(self, source, condition):
480
639
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
640
translations = { "ctrl n": "down", # Emacs
641
"ctrl p": "up", # Emacs
642
"ctrl v": "page down", # Emacs
643
"meta v": "page up", # Emacs
644
" ": "page down", # less
645
"f": "page down", # less
646
"b": "page up", # less
647
"j": "down", # vi
648
"k": "up", # vi
490
649
}
491
650
for key in keys:
492
651
try:
494
653
except KeyError: # :-)
495
654
pass
496
655
497
if key == u"q" or key == u"Q":
656
if key == "q" or key == "Q":
498
657
self.stop()
499
658
break
500
elif key == u"window resize":
659
elif key == "window resize":
501
660
self.size = self.screen.get_cols_rows()
502
661
self.refresh()
503
elif key == u"\f": # Ctrl-L
662
elif key == "\f": # Ctrl-L
504
663
self.refresh()
505
elif key == u"l" or key == u"D":
664
elif key == "l" or key == "D":
506
665
self.toggle_log_display()
507
666
self.refresh()
508
elif key == u"w" or key == u"i":
667
elif key == "w" or key == "i":
509
668
self.change_log_display()
510
669
self.refresh()
511
elif key == u"?" or key == u"f1" or key == u"esc":
670
elif key == "?" or key == "f1" or key == "esc":
512
671
if not self.log_visible:
513
672
self.log_visible = True
514
673
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"))))
674
self.log_message_raw(("bold",
675
" ".
676
join(("q: Quit",
677
"?: Help",
678
"l: Log window toggle",
679
"TAB: Switch window",
680
"w: Wrap (log)"))))
681
self.log_message_raw(("bold",
682
" "
683
.join(("Clients:",
684
"+: Enable",
685
"-: Disable",
686
"R: Remove",
687
"s: Start new checker",
688
"S: Stop checker",
689
"C: Checker OK",
690
"a: Approve",
691
"d: Deny"))))
531
692
self.refresh()
532
elif key == u"tab":
693
elif key == "tab":
533
694
if self.topwidget.get_focus() is self.logbox:
534
695
self.topwidget.set_focus(0)
535
696
else:
536
697
self.topwidget.set_focus(self.logbox)
537
698
self.refresh()
538
#elif (key == u"end" or key == u"meta >" or key == u"G"
539
# or key == u">"):
699
#elif (key == "end" or key == "meta >" or key == "G"
700
# or key == ">"):
540
701
# pass # xxx end-of-buffer
541
#elif (key == u"home" or key == u"meta <" or key == u"g"
542
# or key == u"<"):
702
#elif (key == "home" or key == "meta <" or key == "g"
703
# or key == "<"):
543
704
# pass # xxx beginning-of-buffer
544
#elif key == u"ctrl e" or key == u"$":
705
#elif key == "ctrl e" or key == "$":
545
706
# pass # xxx move-end-of-line
546
#elif key == u"ctrl a" or key == u"^":
707
#elif key == "ctrl a" or key == "^":
547
708
# pass # xxx move-beginning-of-line
548
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
709
#elif key == "ctrl b" or key == "meta (" or key == "h":
549
710
# pass # xxx left
550
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
711
#elif key == "ctrl f" or key == "meta )" or key == "l":
551
712
# pass # xxx right
552
#elif key == u"a":
713
#elif key == "a":
553
714
# pass # scroll up log
554
#elif key == u"z":
715
#elif key == "z":
555
716
# pass # scroll down log
556
717
elif self.topwidget.selectable():
557
718
self.topwidget.keypress(self.size, key)
561
722
ui = UserInterface()
562
723
try:
563
724
ui.run()
725
except KeyboardInterrupt:
726
ui.screen.stop()
564
727
except Exception, e:
565
728
ui.log_message(unicode(e))
566
729
ui.screen.stop()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0