To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to mandos-monitor
- browse files at revision 306
- compare with another revision
- download diff
- download tarball
- view history from revision 306
- Committer: Teddy Hogeborn
- Date: 2013-10-24 20:38:44 UTC
- Revision ID: teddy@recompile.se-20131024203844-j0y0ir6vnlj9mkix
Tags: version-1.6.2-1
* Makefile (version): Changed to "1.6.2".
* NEWS (Version 1.6.2): New entry.
* debian/changelog (1.6.2-1): - '' -
* NEWS (Version 1.6.2): New entry.
* debian/changelog (1.6.2-1): - '' -
- 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-2013 Teddy Hogeborn
7
# Copyright © 2009-2013 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.2"
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
message = (u'A checker has failed! Time until client gets diabled: %s'
250
% unicode(timer).rsplit(".", 1)[0])
251
elif self.properties[u"approved_pending"]:
252
if self.properties[u"approved_by_default"]:
253
message = u"Connection established to client. (d)eny?"
254
else:
255
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)
256
296
else:
257
message = u"enabled"
258
self._text = "%s%s" % (base, message)
259
297
message = "enabled"
298
self.using_timer(False)
299
self._text = "{0}{1}".format(base, message)
300
260
301
if not urwid.supports_unicode():
261
302
self._text = self._text.encode("ascii", "replace")
262
textlist = [(u"normal", self._text)]
303
textlist = [("normal", self._text)]
263
304
self._text_widget.set_text(textlist)
264
305
self._focus_text_widget.set_text([(with_standout[text[0]],
265
306
text[1])
274
315
self.update_hook()
275
316
276
317
def update_timer(self):
277
"called by gobject"
318
"""called by gobject. Will indefinitely loop until
319
gobject.source_remove() on tag is called"""
278
320
self.update()
279
321
return True # Keep calling this
280
322
281
def delete(self):
323
def delete(self, **kwargs):
282
324
if self._update_timer_callback_tag is not None:
283
325
gobject.source_remove(self._update_timer_callback_tag)
284
326
self._update_timer_callback_tag = None
327
for match in self.match_objects:
328
match.remove()
329
self.match_objects = ()
285
330
if self.delete_hook is not None:
286
331
self.delete_hook(self)
332
return super(MandosClientWidget, self).delete(**kwargs)
287
333
288
def render(self, (maxcol,), focus=False):
334
def render(self, maxcolrow, focus=False):
289
335
"""Render differently if we have focus.
290
336
This overrides the method from urwid.FlowWidget"""
291
return self.current_widget(focus).render((maxcol,),
337
return self.current_widget(focus).render(maxcolrow,
292
338
focus=focus)
293
339
294
def keypress(self, (maxcol,), key):
340
def keypress(self, maxcolrow, key):
295
341
"""Handle keys.
296
342
This overrides the method from urwid.FlowWidget"""
297
if key == u"+":
298
self.proxy.Enable(dbus_interface = client_interface)
299
elif key == u"-":
300
self.proxy.Disable(dbus_interface = client_interface)
301
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":
302
350
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
303
dbus_interface = client_interface)
304
elif key == u"d":
351
dbus_interface = client_interface,
352
ignore_reply=True)
353
elif key == "d":
305
354
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
306
dbus_interface = client_interface)
307
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":
308
358
self.server_proxy_object.RemoveClient(self.proxy
309
.object_path)
310
elif key == u"s":
311
self.proxy.StartChecker(dbus_interface = client_interface)
312
elif key == u"S":
313
self.proxy.StopChecker(dbus_interface = client_interface)
314
elif key == u"C":
315
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)
316
370
# xxx
317
# elif key == u"p" or key == "=":
371
# elif key == "p" or key == "=":
318
372
# self.proxy.pause()
319
# elif key == u"u" or key == ":":
373
# elif key == "u" or key == ":":
320
374
# self.proxy.unpause()
321
# elif key == u"RET":
375
# elif key == "RET":
322
376
# self.open()
323
# elif key == u"+":
324
# self.proxy.Approve(True)
325
# elif key == u"-":
326
# self.proxy.Approve(False)
327
377
else:
328
378
return key
329
379
330
def property_changed(self, property=None, value=None,
331
*args, **kwargs):
380
def property_changed(self, property=None, **kwargs):
332
381
"""Call self.update() if old value is not new value.
333
382
This overrides the method from MandosClientPropertyCache"""
334
property_name = unicode(property)
383
property_name = str(property)
335
384
old_value = self.properties.get(property_name)
336
385
super(MandosClientWidget, self).property_changed(
337
property=property, value=value, *args, **kwargs)
386
property=property, **kwargs)
338
387
if self.properties.get(property_name) != old_value:
339
388
self.update()
340
389
344
393
"down" key presses, thus not allowing any containing widgets to
345
394
use them as an excuse to shift focus away from this widget.
346
395
"""
347
def keypress(self, (maxcol, maxrow), key):
348
ret = super(ConstrainedListBox, self).keypress((maxcol, maxrow), key)
349
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"):
350
399
return
351
400
return ret
352
401
361
410
self.screen = urwid.curses_display.Screen()
362
411
363
412
self.screen.register_palette((
364
(u"normal",
365
u"default", u"default", None),
366
(u"bold",
367
u"default", u"default", u"bold"),
368
(u"underline-blink",
369
u"default", u"default", u"underline"),
370
(u"standout",
371
u"default", u"default", u"standout"),
372
(u"bold-underline-blink",
373
u"default", u"default", (u"bold", u"underline")),
374
(u"bold-standout",
375
u"default", u"default", (u"bold", u"standout")),
376
(u"underline-blink-standout",
377
u"default", u"default", (u"underline", u"standout")),
378
(u"bold-underline-blink-standout",
379
u"default", u"default", (u"bold", u"underline",
380
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"),
381
431
))
382
432
383
433
if urwid.supports_unicode():
384
self.divider = u"─" # \u2500
385
#self.divider = u"━" # \u2501
434
self.divider = "─" # \u2500
435
#self.divider = "━" # \u2501
386
436
else:
387
#self.divider = u"-" # \u002d
388
self.divider = u"_" # \u005f
437
#self.divider = "-" # \u002d
438
self.divider = "_" # \u005f
389
439
390
440
self.screen.start()
391
441
405
455
# This keeps track of whether self.uilist currently has
406
456
# self.logbox in it or not
407
457
self.log_visible = True
408
self.log_wrap = u"any"
458
self.log_wrap = "any"
409
459
410
460
self.rebuild()
411
self.log_message_raw((u"bold",
412
u"Mandos Monitor version " + version))
413
self.log_message_raw((u"bold",
414
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"))
415
465
416
466
self.busname = domain + '.Mandos'
417
467
self.main_loop = gobject.MainLoop()
418
self.bus = dbus.SystemBus()
419
mandos_dbus_objc = self.bus.get_object(
420
self.busname, u"/", follow_name_owner_changes=True)
421
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
422
dbus_interface
423
= server_interface)
424
try:
425
mandos_clients = (self.mandos_serv
426
.GetAllClientsWithProperties())
427
except dbus.exceptions.DBusException:
428
mandos_clients = dbus.Dictionary()
429
430
(self.mandos_serv
431
.connect_to_signal(u"ClientRemoved",
432
self.find_and_remove_client,
433
dbus_interface=server_interface,
434
byte_arrays=True))
435
(self.mandos_serv
436
.connect_to_signal(u"ClientAdded",
437
self.add_new_client,
438
dbus_interface=server_interface,
439
byte_arrays=True))
440
(self.mandos_serv
441
.connect_to_signal(u"ClientNotFound",
442
self.client_not_found,
443
dbus_interface=server_interface,
444
byte_arrays=True))
445
for path, client in mandos_clients.iteritems():
446
client_proxy_object = self.bus.get_object(self.busname,
447
path)
448
self.add_client(MandosClientWidget(server_proxy_object
449
=self.mandos_serv,
450
proxy_object
451
=client_proxy_object,
452
properties=client,
453
update_hook
454
=self.refresh,
455
delete_hook
456
=self.remove_client,
457
logger
458
=self.log_message),
459
path=path)
460
468
461
469
def client_not_found(self, fingerprint, address):
462
self.log_message((u"Client with address %s and fingerprint %s"
463
u" could not be found" % (address,
464
fingerprint)))
470
self.log_message("Client with address {0} and fingerprint"
471
" {1} could not be found"
472
.format(address, fingerprint))
465
473
466
474
def rebuild(self):
467
475
"""This rebuilds the User Interface.
468
476
Call this when the widget layout needs to change"""
469
477
self.uilist = []
470
478
#self.uilist.append(urwid.ListBox(self.clients))
471
self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),
479
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
480
clients),
472
481
#header=urwid.Divider(),
473
482
header=None,
474
footer=urwid.Divider(div_char=self.divider)))
483
footer=
484
urwid.Divider(div_char=
485
self.divider)))
475
486
if self.log_visible:
476
487
self.uilist.append(self.logbox)
477
pass
478
488
self.topwidget = urwid.Pile(self.uilist)
479
489
480
490
def log_message(self, message):
491
"""Log message formatted with timestamp"""
481
492
timestamp = datetime.datetime.now().isoformat()
482
self.log_message_raw(timestamp + u": " + message)
493
self.log_message_raw(timestamp + ": " + message)
483
494
484
495
def log_message_raw(self, markup):
485
496
"""Add a log message to the log buffer."""
488
499
and len(self.log) > self.max_log_length):
489
500
del self.log[0:len(self.log)-self.max_log_length-1]
490
501
self.logbox.set_focus(len(self.logbox.body.contents),
491
coming_from=u"above")
502
coming_from="above")
492
503
self.refresh()
493
504
494
505
def toggle_log_display(self):
495
506
"""Toggle visibility of the log buffer."""
496
507
self.log_visible = not self.log_visible
497
508
self.rebuild()
498
self.log_message(u"Log visibility changed to: "
499
+ unicode(self.log_visible))
509
#self.log_message("Log visibility changed to: "
510
# + str(self.log_visible))
500
511
501
512
def change_log_display(self):
502
513
"""Change type of log display.
503
514
Currently, this toggles wrapping of text lines."""
504
if self.log_wrap == u"clip":
505
self.log_wrap = u"any"
515
if self.log_wrap == "clip":
516
self.log_wrap = "any"
506
517
else:
507
self.log_wrap = u"clip"
518
self.log_wrap = "clip"
508
519
for textwidget in self.log:
509
520
textwidget.set_wrap_mode(self.log_wrap)
510
self.log_message(u"Wrap mode: " + self.log_wrap)
521
#self.log_message("Wrap mode: " + self.log_wrap)
511
522
512
523
def find_and_remove_client(self, path, name):
513
"""Find an client from its object path and remove it.
524
"""Find a client by its object path and remove it.
514
525
515
526
This is connected to the ClientRemoved signal from the
516
527
Mandos server object."""
518
529
client = self.clients_dict[path]
519
530
except KeyError:
520
531
# not found?
532
self.log_message("Unknown client {0!r} ({1!r}) removed"
533
.format(name, path))
521
534
return
522
self.remove_client(client, path)
535
client.delete()
523
536
524
537
def add_new_client(self, path):
525
538
client_proxy_object = self.bus.get_object(self.busname, path)
540
553
if path is None:
541
554
path = client.proxy.object_path
542
555
self.clients_dict[path] = client
543
self.clients.sort(None, lambda c: c.properties[u"name"])
556
self.clients.sort(key=lambda c: c.properties["Name"])
544
557
self.refresh()
545
558
546
559
def remove_client(self, client, path=None):
548
561
if path is None:
549
562
path = client.proxy.object_path
550
563
del self.clients_dict[path]
551
if not self.clients_dict:
552
# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
553
# is completely emptied, we need to recreate it.
554
self.clients = urwid.SimpleListWalker([])
555
self.rebuild()
556
564
self.refresh()
557
565
558
566
def refresh(self):
562
570
563
571
def run(self):
564
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
565
619
self.refresh()
566
620
self._input_callback_tag = (gobject.io_add_watch
567
621
(sys.stdin.fileno(),
577
631
578
632
def process_input(self, source, condition):
579
633
keys = self.screen.get_input()
580
translations = { u"ctrl n": u"down", # Emacs
581
u"ctrl p": u"up", # Emacs
582
u"ctrl v": u"page down", # Emacs
583
u"meta v": u"page up", # Emacs
584
u" ": u"page down", # less
585
u"f": u"page down", # less
586
u"b": u"page up", # less
587
u"j": u"down", # vi
588
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
589
643
}
590
644
for key in keys:
591
645
try:
593
647
except KeyError: # :-)
594
648
pass
595
649
596
if key == u"q" or key == u"Q":
650
if key == "q" or key == "Q":
597
651
self.stop()
598
652
break
599
elif key == u"window resize":
653
elif key == "window resize":
600
654
self.size = self.screen.get_cols_rows()
601
655
self.refresh()
602
elif key == u"\f": # Ctrl-L
656
elif key == "\f": # Ctrl-L
603
657
self.refresh()
604
elif key == u"l" or key == u"D":
658
elif key == "l" or key == "D":
605
659
self.toggle_log_display()
606
660
self.refresh()
607
elif key == u"w" or key == u"i":
661
elif key == "w" or key == "i":
608
662
self.change_log_display()
609
663
self.refresh()
610
elif key == u"?" or key == u"f1" or key == u"esc":
664
elif key == "?" or key == "f1" or key == "esc":
611
665
if not self.log_visible:
612
666
self.log_visible = True
613
667
self.rebuild()
614
self.log_message_raw((u"bold",
615
u" ".
616
join((u"q: Quit",
617
u"?: Help",
618
u"l: Log window toggle",
619
u"TAB: Switch window",
620
u"w: Wrap (log)"))))
621
self.log_message_raw((u"bold",
622
u" "
623
.join((u"Clients:",
624
u"+: Enable",
625
u"-: Disable",
626
u"r: Remove",
627
u"s: Start new checker",
628
u"S: Stop checker",
629
u"C: Checker OK",
630
u"a: Approve",
631
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"))))
632
686
self.refresh()
633
elif key == u"tab":
687
elif key == "tab":
634
688
if self.topwidget.get_focus() is self.logbox:
635
689
self.topwidget.set_focus(0)
636
690
else:
637
691
self.topwidget.set_focus(self.logbox)
638
692
self.refresh()
639
#elif (key == u"end" or key == u"meta >" or key == u"G"
640
# or key == u">"):
693
#elif (key == "end" or key == "meta >" or key == "G"
694
# or key == ">"):
641
695
# pass # xxx end-of-buffer
642
#elif (key == u"home" or key == u"meta <" or key == u"g"
643
# or key == u"<"):
696
#elif (key == "home" or key == "meta <" or key == "g"
697
# or key == "<"):
644
698
# pass # xxx beginning-of-buffer
645
#elif key == u"ctrl e" or key == u"$":
699
#elif key == "ctrl e" or key == "$":
646
700
# pass # xxx move-end-of-line
647
#elif key == u"ctrl a" or key == u"^":
701
#elif key == "ctrl a" or key == "^":
648
702
# pass # xxx move-beginning-of-line
649
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
703
#elif key == "ctrl b" or key == "meta (" or key == "h":
650
704
# pass # xxx left
651
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
705
#elif key == "ctrl f" or key == "meta )" or key == "l":
652
706
# pass # xxx right
653
#elif key == u"a":
707
#elif key == "a":
654
708
# pass # scroll up log
655
#elif key == u"z":
709
#elif key == "z":
656
710
# pass # scroll down log
657
711
elif self.topwidget.selectable():
658
712
self.topwidget.keypress(self.size, key)
662
716
ui = UserInterface()
663
717
try:
664
718
ui.run()
665
except Exception, e:
666
ui.log_message(unicode(e))
719
except KeyboardInterrupt:
720
ui.screen.stop()
721
except Exception as e:
722
ui.log_message(str(e))
667
723
ui.screen.stop()
668
724
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0