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