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 647
- compare with another revision
- download diff
- download tarball
- view history from revision 647
- Committer: Teddy Hogeborn
- Date: 2013-12-31 16:02:18 UTC
- Revision ID: teddy@recompile.se-20131231160218-plmmb0o0iifkd5l2
Specify BusName in systemd service file.
* mandos.service (BusName): Uncommented.
* mandos.service (BusName): Uncommented.
- files added:
- debian/mandos-client.examples
- debian/source
- network-hooks.d
- files modified:
- .bzrignore
added
removed
mandos-monitor
1
1
#!/usr/bin/python
2
2
# -*- mode: python; coding: utf-8 -*-
3
#
4
# Mandos Monitor - Control and monitor the Mandos server
5
#
6
# Copyright © 2009-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._update_timer_callback_lock = 0
106
self.last_checker_failed = False
107
135
108
136
# The widget shown normally
109
self._text_widget = urwid.Text(u"")
137
self._text_widget = urwid.Text("")
110
138
# The widget shown when we have focus
111
self._focus_text_widget = urwid.Text(u"")
112
super(MandosClientWidget, self).__init__(
113
update_hook=update_hook, delete_hook=delete_hook,
114
*args, **kwargs)
139
self._focus_text_widget = urwid.Text("")
140
super(MandosClientWidget, self).__init__(**kwargs)
115
141
self.update()
116
142
self.opened = False
117
143
118
last_checked_ok = isoformat_to_datetime(self.properties
119
[u"LastCheckedOK"])
120
if last_checked_ok is None:
121
self.last_checker_failed = True
122
else:
123
self.last_checker_failed = ((datetime.datetime.utcnow()
124
- last_checked_ok)
125
> datetime.timedelta
126
(milliseconds=
127
self.properties
128
[u"Interval"]))
129
130
if self.last_checker_failed:
131
self.using_timer(True)
132
133
if self.need_approval:
134
self.using_timer(True)
135
136
self.proxy.connect_to_signal(u"CheckerCompleted",
137
self.checker_completed,
138
client_interface,
139
byte_arrays=True)
140
self.proxy.connect_to_signal(u"CheckerStarted",
141
self.checker_started,
142
client_interface,
143
byte_arrays=True)
144
self.proxy.connect_to_signal(u"GotSecret",
145
self.got_secret,
146
client_interface,
147
byte_arrays=True)
148
self.proxy.connect_to_signal(u"NeedApproval",
149
self.need_approval,
150
client_interface,
151
byte_arrays=True)
152
self.proxy.connect_to_signal(u"Rejected",
153
self.rejected,
154
client_interface,
155
byte_arrays=True)
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"]))
156
167
157
def property_changed(self, property=None, value=None):
158
super(self, MandosClientWidget).property_changed(property,
159
value)
160
if property == u"ApprovalPending":
161
using_timer(bool(value))
162
163
168
def using_timer(self, flag):
164
169
"""Call this method with True or False when timer should be
165
170
activated or deactivated.
166
171
"""
167
old = self._update_timer_callback_lock
168
if flag:
169
self._update_timer_callback_lock += 1
170
else:
171
self._update_timer_callback_lock -= 1
172
if old == 0 and self._update_timer_callback_lock:
172
if flag and self._update_timer_callback_tag is None:
173
# Will update the shown timer value every second
173
174
self._update_timer_callback_tag = (gobject.timeout_add
174
175
(1000,
175
176
self.update_timer))
176
elif old and self._update_timer_callback_lock == 0:
177
elif not (flag or self._update_timer_callback_tag is None):
177
178
gobject.source_remove(self._update_timer_callback_tag)
178
179
self._update_timer_callback_tag = None
179
180
180
181
def checker_completed(self, exitstatus, condition, command):
181
182
if exitstatus == 0:
182
if self.last_checker_failed:
183
self.last_checker_failed = False
184
self.using_timer(False)
185
#self.logger(u'Checker for client %s (command "%s")'
186
# u' was successful'
187
# % (self.properties[u"Name"], command))
188
183
self.update()
189
184
return
190
185
# Checker failed
191
if not self.last_checker_failed:
192
self.last_checker_failed = True
193
self.using_timer(True)
194
186
if os.WIFEXITED(condition):
195
self.logger(u'Checker for client %s (command "%s")'
196
u' failed with exit code %s'
197
% (self.properties[u"Name"], command,
198
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)))
199
191
elif os.WIFSIGNALED(condition):
200
self.logger(u'Checker for client %s (command "%s")'
201
u' was killed by signal %s'
202
% (self.properties[u"Name"], command,
203
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)))
204
196
elif os.WCOREDUMP(condition):
205
self.logger(u'Checker for client %s (command "%s")'
206
u' dumped core'
207
% (self.properties[u"Name"], command))
197
self.logger('Checker for client {0} (command "{1}")'
198
' dumped core'
199
.format(self.properties["Name"], command))
208
200
else:
209
self.logger(u'Checker for client %s completed'
210
u' mysteriously')
201
self.logger('Checker for client {0} completed'
202
' mysteriously'
203
.format(self.properties["Name"]))
211
204
self.update()
212
205
213
206
def checker_started(self, command):
214
#self.logger(u'Client %s started checker "%s"'
215
# % (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)))
216
212
pass
217
213
218
214
def got_secret(self):
219
self.last_checker_failed = False
220
self.logger(u'Client %s received its secret'
221
% self.properties[u"Name"])
215
self.logger('Client {0} received its secret'
216
.format(self.properties["Name"]))
222
217
223
218
def need_approval(self, timeout, default):
224
219
if not default:
225
message = u'Client %s needs approval within %s seconds'
220
message = 'Client {0} needs approval within {1} seconds'
226
221
else:
227
message = u'Client %s will get its secret in %s seconds'
228
self.logger(message
229
% (self.properties[u"Name"], timeout/1000))
230
self.using_timer(True)
222
message = 'Client {0} will get its secret in {1} seconds'
223
self.logger(message.format(self.properties["Name"],
224
timeout/1000))
231
225
232
226
def rejected(self, reason):
233
self.logger(u'Client %s was rejected; reason: %s'
234
% (self.properties[u"Name"], reason))
227
self.logger('Client {0} was rejected; reason: {1}'
228
.format(self.properties["Name"], reason))
235
229
236
230
def selectable(self):
237
231
"""Make this a "selectable" widget.
238
232
This overrides the method from urwid.FlowWidget."""
239
233
return True
240
234
241
def rows(self, (maxcol,), focus=False):
235
def rows(self, maxcolrow, focus=False):
242
236
"""How many rows this widget will occupy might depend on
243
237
whether we have focus or not.
244
238
This overrides the method from urwid.FlowWidget"""
245
return self.current_widget(focus).rows((maxcol,), focus=focus)
239
return self.current_widget(focus).rows(maxcolrow, focus=focus)
246
240
247
241
def current_widget(self, focus=False):
248
242
if focus or self.opened:
252
246
def update(self):
253
247
"Called when what is visible on the screen should be updated."
254
248
# How to add standout mode to a style
255
with_standout = { u"normal": u"standout",
256
u"bold": u"bold-standout",
257
u"underline-blink":
258
u"underline-blink-standout",
259
u"bold-underline-blink":
260
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",
261
255
}
262
256
263
257
# Rebuild focus and non-focus widgets using current properties
264
258
265
259
# Base part of a client. Name!
266
base = (u'%(name)s: '
267
% {u"name": self.properties[u"Name"]})
268
if not self.properties[u"Enabled"]:
269
message = u"DISABLED"
270
elif self.properties[u"ApprovalPending"]:
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"]:
271
265
timeout = datetime.timedelta(milliseconds
272
266
= self.properties
273
[u"ApprovalDelay"])
267
["ApprovalDelay"])
274
268
last_approval_request = isoformat_to_datetime(
275
self.properties[u"LastApprovalRequest"])
269
self.properties["LastApprovalRequest"])
276
270
if last_approval_request is not None:
277
timer = timeout - (datetime.datetime.utcnow()
278
- last_approval_request)
271
timer = max(timeout - (datetime.datetime.utcnow()
272
- last_approval_request),
273
datetime.timedelta())
279
274
else:
280
275
timer = datetime.timedelta()
281
if self.properties[u"ApprovedByDefault"]:
282
message = u"Approval in %s. (d)eny?"
283
else:
284
message = u"Denial in %s. (a)pprove?"
285
message = message % unicode(timer).rsplit(".", 1)[0]
286
elif self.last_checker_failed:
287
timeout = datetime.timedelta(milliseconds
288
= self.properties
289
[u"Timeout"])
290
last_ok = isoformat_to_datetime(
291
max((self.properties[u"LastCheckedOK"]
292
or self.properties[u"Created"]),
293
self.properties[u"LastEnabled"]))
294
timer = timeout - (datetime.datetime.utcnow() - last_ok)
295
message = (u'A checker has failed! Time until client'
296
u' gets disabled: %s'
297
% unicode(timer).rsplit(".", 1)[0])
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)
298
296
else:
299
message = u"enabled"
300
self._text = "%s%s" % (base, message)
301
297
message = "enabled"
298
self.using_timer(False)
299
self._text = "{0}{1}".format(base, message)
300
302
301
if not urwid.supports_unicode():
303
302
self._text = self._text.encode("ascii", "replace")
304
textlist = [(u"normal", self._text)]
303
textlist = [("normal", self._text)]
305
304
self._text_widget.set_text(textlist)
306
305
self._focus_text_widget.set_text([(with_standout[text[0]],
307
306
text[1])
316
315
self.update_hook()
317
316
318
317
def update_timer(self):
319
"called by gobject"
318
"""called by gobject. Will indefinitely loop until
319
gobject.source_remove() on tag is called"""
320
320
self.update()
321
321
return True # Keep calling this
322
322
323
def delete(self):
323
def delete(self, **kwargs):
324
324
if self._update_timer_callback_tag is not None:
325
325
gobject.source_remove(self._update_timer_callback_tag)
326
326
self._update_timer_callback_tag = None
327
for match in self.match_objects:
328
match.remove()
329
self.match_objects = ()
327
330
if self.delete_hook is not None:
328
331
self.delete_hook(self)
332
return super(MandosClientWidget, self).delete(**kwargs)
329
333
330
def render(self, (maxcol,), focus=False):
334
def render(self, maxcolrow, focus=False):
331
335
"""Render differently if we have focus.
332
336
This overrides the method from urwid.FlowWidget"""
333
return self.current_widget(focus).render((maxcol,),
337
return self.current_widget(focus).render(maxcolrow,
334
338
focus=focus)
335
339
336
def keypress(self, (maxcol,), key):
340
def keypress(self, maxcolrow, key):
337
341
"""Handle keys.
338
342
This overrides the method from urwid.FlowWidget"""
339
if key == u"+":
340
self.proxy.Enable(dbus_interface = client_interface)
341
elif key == u"-":
342
self.proxy.Disable(dbus_interface = client_interface)
343
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":
344
350
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
345
dbus_interface = client_interface)
346
elif key == u"d":
351
dbus_interface = client_interface,
352
ignore_reply=True)
353
elif key == "d":
347
354
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
348
dbus_interface = client_interface)
349
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":
350
358
self.server_proxy_object.RemoveClient(self.proxy
351
.object_path)
352
elif key == u"s":
353
self.proxy.StartChecker(dbus_interface = client_interface)
354
elif key == u"S":
355
self.proxy.StopChecker(dbus_interface = client_interface)
356
elif key == u"C":
357
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)
358
370
# xxx
359
# elif key == u"p" or key == "=":
371
# elif key == "p" or key == "=":
360
372
# self.proxy.pause()
361
# elif key == u"u" or key == ":":
373
# elif key == "u" or key == ":":
362
374
# self.proxy.unpause()
363
# elif key == u"RET":
375
# elif key == "RET":
364
376
# self.open()
365
377
else:
366
378
return key
367
379
368
def property_changed(self, property=None, value=None,
369
*args, **kwargs):
380
def property_changed(self, property=None, **kwargs):
370
381
"""Call self.update() if old value is not new value.
371
382
This overrides the method from MandosClientPropertyCache"""
372
property_name = unicode(property)
383
property_name = str(property)
373
384
old_value = self.properties.get(property_name)
374
385
super(MandosClientWidget, self).property_changed(
375
property=property, value=value, *args, **kwargs)
386
property=property, **kwargs)
376
387
if self.properties.get(property_name) != old_value:
377
388
self.update()
378
389
382
393
"down" key presses, thus not allowing any containing widgets to
383
394
use them as an excuse to shift focus away from this widget.
384
395
"""
385
def keypress(self, (maxcol, maxrow), key):
386
ret = super(ConstrainedListBox, self).keypress((maxcol,
387
maxrow), key)
388
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"):
389
399
return
390
400
return ret
391
401
400
410
self.screen = urwid.curses_display.Screen()
401
411
402
412
self.screen.register_palette((
403
(u"normal",
404
u"default", u"default", None),
405
(u"bold",
406
u"default", u"default", u"bold"),
407
(u"underline-blink",
408
u"default", u"default", u"underline"),
409
(u"standout",
410
u"default", u"default", u"standout"),
411
(u"bold-underline-blink",
412
u"default", u"default", (u"bold", u"underline")),
413
(u"bold-standout",
414
u"default", u"default", (u"bold", u"standout")),
415
(u"underline-blink-standout",
416
u"default", u"default", (u"underline", u"standout")),
417
(u"bold-underline-blink-standout",
418
u"default", u"default", (u"bold", u"underline",
419
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"),
420
431
))
421
432
422
433
if urwid.supports_unicode():
423
self.divider = u"─" # \u2500
424
#self.divider = u"━" # \u2501
434
self.divider = "─" # \u2500
435
#self.divider = "━" # \u2501
425
436
else:
426
#self.divider = u"-" # \u002d
427
self.divider = u"_" # \u005f
437
#self.divider = "-" # \u002d
438
self.divider = "_" # \u005f
428
439
429
440
self.screen.start()
430
441
444
455
# This keeps track of whether self.uilist currently has
445
456
# self.logbox in it or not
446
457
self.log_visible = True
447
self.log_wrap = u"any"
458
self.log_wrap = "any"
448
459
449
460
self.rebuild()
450
self.log_message_raw((u"bold",
451
u"Mandos Monitor version " + version))
452
self.log_message_raw((u"bold",
453
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"))
454
465
455
466
self.busname = domain + '.Mandos'
456
467
self.main_loop = gobject.MainLoop()
457
self.bus = dbus.SystemBus()
458
mandos_dbus_objc = self.bus.get_object(
459
self.busname, u"/", follow_name_owner_changes=True)
460
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
461
dbus_interface
462
= server_interface)
463
try:
464
mandos_clients = (self.mandos_serv
465
.GetAllClientsWithProperties())
466
except dbus.exceptions.DBusException:
467
mandos_clients = dbus.Dictionary()
468
469
(self.mandos_serv
470
.connect_to_signal(u"ClientRemoved",
471
self.find_and_remove_client,
472
dbus_interface=server_interface,
473
byte_arrays=True))
474
(self.mandos_serv
475
.connect_to_signal(u"ClientAdded",
476
self.add_new_client,
477
dbus_interface=server_interface,
478
byte_arrays=True))
479
(self.mandos_serv
480
.connect_to_signal(u"ClientNotFound",
481
self.client_not_found,
482
dbus_interface=server_interface,
483
byte_arrays=True))
484
for path, client in mandos_clients.iteritems():
485
client_proxy_object = self.bus.get_object(self.busname,
486
path)
487
self.add_client(MandosClientWidget(server_proxy_object
488
=self.mandos_serv,
489
proxy_object
490
=client_proxy_object,
491
properties=client,
492
update_hook
493
=self.refresh,
494
delete_hook
495
=self.remove_client,
496
logger
497
=self.log_message),
498
path=path)
499
468
500
469
def client_not_found(self, fingerprint, address):
501
self.log_message((u"Client with address %s and fingerprint %s"
502
u" could not be found" % (address,
503
fingerprint)))
470
self.log_message("Client with address {0} and fingerprint"
471
" {1} could not be found"
472
.format(address, fingerprint))
504
473
505
474
def rebuild(self):
506
475
"""This rebuilds the User Interface.
516
485
self.divider)))
517
486
if self.log_visible:
518
487
self.uilist.append(self.logbox)
519
pass
520
488
self.topwidget = urwid.Pile(self.uilist)
521
489
522
490
def log_message(self, message):
491
"""Log message formatted with timestamp"""
523
492
timestamp = datetime.datetime.now().isoformat()
524
self.log_message_raw(timestamp + u": " + message)
493
self.log_message_raw(timestamp + ": " + message)
525
494
526
495
def log_message_raw(self, markup):
527
496
"""Add a log message to the log buffer."""
530
499
and len(self.log) > self.max_log_length):
531
500
del self.log[0:len(self.log)-self.max_log_length-1]
532
501
self.logbox.set_focus(len(self.logbox.body.contents),
533
coming_from=u"above")
502
coming_from="above")
534
503
self.refresh()
535
504
536
505
def toggle_log_display(self):
537
506
"""Toggle visibility of the log buffer."""
538
507
self.log_visible = not self.log_visible
539
508
self.rebuild()
540
#self.log_message(u"Log visibility changed to: "
541
# + unicode(self.log_visible))
509
#self.log_message("Log visibility changed to: "
510
# + str(self.log_visible))
542
511
543
512
def change_log_display(self):
544
513
"""Change type of log display.
545
514
Currently, this toggles wrapping of text lines."""
546
if self.log_wrap == u"clip":
547
self.log_wrap = u"any"
515
if self.log_wrap == "clip":
516
self.log_wrap = "any"
548
517
else:
549
self.log_wrap = u"clip"
518
self.log_wrap = "clip"
550
519
for textwidget in self.log:
551
520
textwidget.set_wrap_mode(self.log_wrap)
552
#self.log_message(u"Wrap mode: " + self.log_wrap)
521
#self.log_message("Wrap mode: " + self.log_wrap)
553
522
554
523
def find_and_remove_client(self, path, name):
555
"""Find an client from its object path and remove it.
524
"""Find a client by its object path and remove it.
556
525
557
526
This is connected to the ClientRemoved signal from the
558
527
Mandos server object."""
560
529
client = self.clients_dict[path]
561
530
except KeyError:
562
531
# not found?
532
self.log_message("Unknown client {0!r} ({1!r}) removed"
533
.format(name, path))
563
534
return
564
self.remove_client(client, path)
535
client.delete()
565
536
566
537
def add_new_client(self, path):
567
538
client_proxy_object = self.bus.get_object(self.busname, path)
582
553
if path is None:
583
554
path = client.proxy.object_path
584
555
self.clients_dict[path] = client
585
self.clients.sort(None, lambda c: c.properties[u"Name"])
556
self.clients.sort(key=lambda c: c.properties["Name"])
586
557
self.refresh()
587
558
588
559
def remove_client(self, client, path=None):
590
561
if path is None:
591
562
path = client.proxy.object_path
592
563
del self.clients_dict[path]
593
if not self.clients_dict:
594
# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
595
# is completely emptied, we need to recreate it.
596
self.clients = urwid.SimpleListWalker([])
597
self.rebuild()
598
564
self.refresh()
599
565
600
566
def refresh(self):
604
570
605
571
def run(self):
606
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
607
619
self.refresh()
608
620
self._input_callback_tag = (gobject.io_add_watch
609
621
(sys.stdin.fileno(),
619
631
620
632
def process_input(self, source, condition):
621
633
keys = self.screen.get_input()
622
translations = { u"ctrl n": u"down", # Emacs
623
u"ctrl p": u"up", # Emacs
624
u"ctrl v": u"page down", # Emacs
625
u"meta v": u"page up", # Emacs
626
u" ": u"page down", # less
627
u"f": u"page down", # less
628
u"b": u"page up", # less
629
u"j": u"down", # vi
630
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
631
643
}
632
644
for key in keys:
633
645
try:
635
647
except KeyError: # :-)
636
648
pass
637
649
638
if key == u"q" or key == u"Q":
650
if key == "q" or key == "Q":
639
651
self.stop()
640
652
break
641
elif key == u"window resize":
653
elif key == "window resize":
642
654
self.size = self.screen.get_cols_rows()
643
655
self.refresh()
644
elif key == u"\f": # Ctrl-L
656
elif key == "\f": # Ctrl-L
645
657
self.refresh()
646
elif key == u"l" or key == u"D":
658
elif key == "l" or key == "D":
647
659
self.toggle_log_display()
648
660
self.refresh()
649
elif key == u"w" or key == u"i":
661
elif key == "w" or key == "i":
650
662
self.change_log_display()
651
663
self.refresh()
652
elif key == u"?" or key == u"f1" or key == u"esc":
664
elif key == "?" or key == "f1" or key == "esc":
653
665
if not self.log_visible:
654
666
self.log_visible = True
655
667
self.rebuild()
656
self.log_message_raw((u"bold",
657
u" ".
658
join((u"q: Quit",
659
u"?: Help",
660
u"l: Log window toggle",
661
u"TAB: Switch window",
662
u"w: Wrap (log)"))))
663
self.log_message_raw((u"bold",
664
u" "
665
.join((u"Clients:",
666
u"+: Enable",
667
u"-: Disable",
668
u"r: Remove",
669
u"s: Start new checker",
670
u"S: Stop checker",
671
u"C: Checker OK",
672
u"a: Approve",
673
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"))))
674
686
self.refresh()
675
elif key == u"tab":
687
elif key == "tab":
676
688
if self.topwidget.get_focus() is self.logbox:
677
689
self.topwidget.set_focus(0)
678
690
else:
679
691
self.topwidget.set_focus(self.logbox)
680
692
self.refresh()
681
#elif (key == u"end" or key == u"meta >" or key == u"G"
682
# or key == u">"):
693
#elif (key == "end" or key == "meta >" or key == "G"
694
# or key == ">"):
683
695
# pass # xxx end-of-buffer
684
#elif (key == u"home" or key == u"meta <" or key == u"g"
685
# or key == u"<"):
696
#elif (key == "home" or key == "meta <" or key == "g"
697
# or key == "<"):
686
698
# pass # xxx beginning-of-buffer
687
#elif key == u"ctrl e" or key == u"$":
699
#elif key == "ctrl e" or key == "$":
688
700
# pass # xxx move-end-of-line
689
#elif key == u"ctrl a" or key == u"^":
701
#elif key == "ctrl a" or key == "^":
690
702
# pass # xxx move-beginning-of-line
691
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
703
#elif key == "ctrl b" or key == "meta (" or key == "h":
692
704
# pass # xxx left
693
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
705
#elif key == "ctrl f" or key == "meta )" or key == "l":
694
706
# pass # xxx right
695
#elif key == u"a":
707
#elif key == "a":
696
708
# pass # scroll up log
697
#elif key == u"z":
709
#elif key == "z":
698
710
# pass # scroll down log
699
711
elif self.topwidget.selectable():
700
712
self.topwidget.keypress(self.size, key)
706
718
ui.run()
707
719
except KeyboardInterrupt:
708
720
ui.screen.stop()
709
except Exception, e:
710
ui.log_message(unicode(e))
721
except Exception as e:
722
ui.log_message(str(e))
711
723
ui.screen.stop()
712
724
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0