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 237.2.206
- compare with another revision
- download diff
- download tarball
- view history from revision 237.2.206
- Committer: Teddy Hogeborn
- Date: 2010-09-26 17:44:43 UTC
- mto: (24.1.168 mandos) (237.12.2 mandos-persistent) (299.1.1 release) (300.1.1 release) (301.1.1 release)
- mto: This revision was merged to the branch mainline in revision 270.
- Revision ID: teddy@fukt.bsnet.se-20100926174443-452k363uuvczuuzg
* mandos-ctl: Also show "LastApprovalRequest" property.
- files removed:
- 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
#
25
3
26
from __future__ import (division, absolute_import, print_function,
27
unicode_literals)
28
try:
29
from future_builtins import *
30
except ImportError:
31
pass
4
from __future__ import division, absolute_import, with_statement
32
5
33
6
import sys
34
7
import os
40
13
import urwid
41
14
42
15
from dbus.mainloop.glib import DBusGMainLoop
43
try:
44
import gobject
45
except ImportError:
46
from gi.repository import GObject as gobject
16
import gobject
47
17
48
18
import dbus
49
19
20
import UserList
21
50
22
import locale
51
23
52
if sys.version_info[0] == 2:
53
str = unicode
54
55
locale.setlocale(locale.LC_ALL, '')
24
locale.setlocale(locale.LC_ALL, u'')
56
25
57
26
import logging
58
27
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
59
28
60
29
# Some useful constants
61
domain = 'se.recompile'
30
domain = 'se.bsnet.fukt'
62
31
server_interface = domain + '.Mandos'
63
32
client_interface = domain + '.Mandos.Client'
64
version = "1.6.3"
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)
65
42
66
43
def isoformat_to_datetime(iso):
67
44
"Parse an ISO 8601 date string to a datetime.datetime()"
68
45
if not iso:
69
46
return None
70
d, t = iso.split("T", 1)
71
year, month, day = d.split("-", 2)
72
hour, minute, second = t.split(":", 2)
47
d, t = iso.split(u"T", 1)
48
year, month, day = d.split(u"-", 2)
49
hour, minute, second = t.split(u":", 2)
73
50
second, fraction = divmod(float(second), 1)
74
51
return datetime.datetime(int(year),
75
52
int(month),
84
61
properties and calls a hook function when any of them are
85
62
changed.
86
63
"""
87
def __init__(self, proxy_object=None, properties=None, **kwargs):
64
def __init__(self, proxy_object=None, *args, **kwargs):
88
65
self.proxy = proxy_object # Mandos Client proxy object
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)
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)
107
80
108
81
def property_changed(self, property=None, value=None):
109
82
"""This is called whenever we get a PropertyChanged signal
111
84
"""
112
85
# Update properties dict with new value
113
86
self.properties[property] = value
114
115
def delete(self):
116
self.property_changed_match.remove()
117
87
118
88
119
89
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
121
91
"""
122
92
123
93
def __init__(self, server_proxy_object=None, update_hook=None,
124
delete_hook=None, logger=None, **kwargs):
94
delete_hook=None, logger=None, *args, **kwargs):
125
95
# Called on update
126
96
self.update_hook = update_hook
127
97
# Called on delete
132
102
self.logger = logger
133
103
134
104
self._update_timer_callback_tag = None
105
self._update_timer_callback_lock = 0
106
self.last_checker_failed = False
135
107
136
108
# The widget shown normally
137
self._text_widget = urwid.Text("")
109
self._text_widget = urwid.Text(u"")
138
110
# The widget shown when we have focus
139
self._focus_text_widget = urwid.Text("")
140
super(MandosClientWidget, self).__init__(**kwargs)
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)
141
115
self.update()
142
116
self.opened = False
143
117
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"]))
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)
167
156
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
168
163
def using_timer(self, flag):
169
164
"""Call this method with True or False when timer should be
170
165
activated or deactivated.
171
166
"""
172
if flag and self._update_timer_callback_tag is None:
173
# Will update the shown timer value every second
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:
174
173
self._update_timer_callback_tag = (gobject.timeout_add
175
174
(1000,
176
175
self.update_timer))
177
elif not (flag or self._update_timer_callback_tag is None):
176
elif old and self._update_timer_callback_lock == 0:
178
177
gobject.source_remove(self._update_timer_callback_tag)
179
178
self._update_timer_callback_tag = None
180
179
181
180
def checker_completed(self, exitstatus, condition, command):
182
181
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))
183
188
self.update()
184
189
return
185
190
# Checker failed
191
if not self.last_checker_failed:
192
self.last_checker_failed = True
193
self.using_timer(True)
186
194
if os.WIFEXITED(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)))
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)))
191
199
elif os.WIFSIGNALED(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)))
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)))
196
204
elif os.WCOREDUMP(condition):
197
self.logger('Checker for client {0} (command "{1}")'
198
' dumped core'
199
.format(self.properties["Name"], command))
205
self.logger(u'Checker for client %s (command "%s")'
206
u' dumped core'
207
% (self.properties[u"Name"], command))
200
208
else:
201
self.logger('Checker for client {0} completed'
202
' mysteriously'
203
.format(self.properties["Name"]))
209
self.logger(u'Checker for client %s completed'
210
u' mysteriously')
204
211
self.update()
205
212
206
213
def checker_started(self, 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)))
214
#self.logger(u'Client %s started checker "%s"'
215
# % (self.properties[u"Name"], unicode(command)))
212
216
pass
213
217
214
218
def got_secret(self):
215
self.logger('Client {0} received its secret'
216
.format(self.properties["Name"]))
219
self.last_checker_failed = False
220
self.logger(u'Client %s received its secret'
221
% self.properties[u"Name"])
217
222
218
223
def need_approval(self, timeout, default):
219
224
if not default:
220
message = 'Client {0} needs approval within {1} seconds'
225
message = u'Client %s needs approval within %s seconds'
221
226
else:
222
message = 'Client {0} will get its secret in {1} seconds'
223
self.logger(message.format(self.properties["Name"],
224
timeout/1000))
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)
225
231
226
232
def rejected(self, reason):
227
self.logger('Client {0} was rejected; reason: {1}'
228
.format(self.properties["Name"], reason))
233
self.logger(u'Client %s was rejected; reason: %s'
234
% (self.properties[u"Name"], reason))
229
235
230
236
def selectable(self):
231
237
"""Make this a "selectable" widget.
232
238
This overrides the method from urwid.FlowWidget."""
233
239
return True
234
240
235
def rows(self, maxcolrow, focus=False):
241
def rows(self, (maxcol,), focus=False):
236
242
"""How many rows this widget will occupy might depend on
237
243
whether we have focus or not.
238
244
This overrides the method from urwid.FlowWidget"""
239
return self.current_widget(focus).rows(maxcolrow, focus=focus)
245
return self.current_widget(focus).rows((maxcol,), focus=focus)
240
246
241
247
def current_widget(self, focus=False):
242
248
if focus or self.opened:
246
252
def update(self):
247
253
"Called when what is visible on the screen should be updated."
248
254
# How to add standout mode to a style
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",
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",
255
261
}
256
262
257
263
# Rebuild focus and non-focus widgets using current properties
258
264
259
265
# Base part of a client. Name!
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"]:
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"]:
265
271
timeout = datetime.timedelta(milliseconds
266
272
= self.properties
267
["ApprovalDelay"])
273
[u"ApprovalDelay"])
268
274
last_approval_request = isoformat_to_datetime(
269
self.properties["LastApprovalRequest"])
275
self.properties[u"LastApprovalRequest"])
270
276
if last_approval_request is not None:
271
timer = max(timeout - (datetime.datetime.utcnow()
272
- last_approval_request),
273
datetime.timedelta())
277
timer = timeout - (datetime.datetime.utcnow()
278
- last_approval_request)
274
279
else:
275
280
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)
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])
296
298
else:
297
message = "enabled"
298
self.using_timer(False)
299
self._text = "{0}{1}".format(base, message)
300
299
message = u"enabled"
300
self._text = "%s%s" % (base, message)
301
301
302
if not urwid.supports_unicode():
302
303
self._text = self._text.encode("ascii", "replace")
303
textlist = [("normal", self._text)]
304
textlist = [(u"normal", self._text)]
304
305
self._text_widget.set_text(textlist)
305
306
self._focus_text_widget.set_text([(with_standout[text[0]],
306
307
text[1])
315
316
self.update_hook()
316
317
317
318
def update_timer(self):
318
"""called by gobject. Will indefinitely loop until
319
gobject.source_remove() on tag is called"""
319
"called by gobject"
320
320
self.update()
321
321
return True # Keep calling this
322
322
323
def delete(self, **kwargs):
323
def delete(self):
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 = ()
330
327
if self.delete_hook is not None:
331
328
self.delete_hook(self)
332
return super(MandosClientWidget, self).delete(**kwargs)
333
329
334
def render(self, maxcolrow, focus=False):
330
def render(self, (maxcol,), focus=False):
335
331
"""Render differently if we have focus.
336
332
This overrides the method from urwid.FlowWidget"""
337
return self.current_widget(focus).render(maxcolrow,
333
return self.current_widget(focus).render((maxcol,),
338
334
focus=focus)
339
335
340
def keypress(self, maxcolrow, key):
336
def keypress(self, (maxcol,), key):
341
337
"""Handle keys.
342
338
This overrides the method from urwid.FlowWidget"""
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":
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":
350
344
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
351
dbus_interface = client_interface,
352
ignore_reply=True)
353
elif key == "d":
345
dbus_interface = client_interface)
346
elif key == u"d":
354
347
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
355
dbus_interface = client_interface,
356
ignore_reply=True)
357
elif key == "R" or key == "_" or key == "ctrl k":
348
dbus_interface = client_interface)
349
elif key == u"r" or key == u"_" or key == u"ctrl k":
358
350
self.server_proxy_object.RemoveClient(self.proxy
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)
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)
370
358
# xxx
371
# elif key == "p" or key == "=":
359
# elif key == u"p" or key == "=":
372
360
# self.proxy.pause()
373
# elif key == "u" or key == ":":
361
# elif key == u"u" or key == ":":
374
362
# self.proxy.unpause()
375
# elif key == "RET":
363
# elif key == u"RET":
376
364
# self.open()
377
365
else:
378
366
return key
379
367
380
def property_changed(self, property=None, **kwargs):
368
def property_changed(self, property=None, value=None,
369
*args, **kwargs):
381
370
"""Call self.update() if old value is not new value.
382
371
This overrides the method from MandosClientPropertyCache"""
383
property_name = str(property)
372
property_name = unicode(property)
384
373
old_value = self.properties.get(property_name)
385
374
super(MandosClientWidget, self).property_changed(
386
property=property, **kwargs)
375
property=property, value=value, *args, **kwargs)
387
376
if self.properties.get(property_name) != old_value:
388
377
self.update()
389
378
393
382
"down" key presses, thus not allowing any containing widgets to
394
383
use them as an excuse to shift focus away from this widget.
395
384
"""
396
def keypress(self, *args, **kwargs):
397
ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
398
if ret in ("up", "down"):
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"):
399
389
return
400
390
return ret
401
391
410
400
self.screen = urwid.curses_display.Screen()
411
401
412
402
self.screen.register_palette((
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"),
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")),
431
420
))
432
421
433
422
if urwid.supports_unicode():
434
self.divider = "─" # \u2500
435
#self.divider = "━" # \u2501
423
self.divider = u"─" # \u2500
424
#self.divider = u"━" # \u2501
436
425
else:
437
#self.divider = "-" # \u002d
438
self.divider = "_" # \u005f
426
#self.divider = u"-" # \u002d
427
self.divider = u"_" # \u005f
439
428
440
429
self.screen.start()
441
430
455
444
# This keeps track of whether self.uilist currently has
456
445
# self.logbox in it or not
457
446
self.log_visible = True
458
self.log_wrap = "any"
447
self.log_wrap = u"any"
459
448
460
449
self.rebuild()
461
self.log_message_raw(("bold",
462
"Mandos Monitor version " + version))
463
self.log_message_raw(("bold",
464
"q: Quit ?: Help"))
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"))
465
454
466
455
self.busname = domain + '.Mandos'
467
456
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)
468
499
469
500
def client_not_found(self, fingerprint, address):
470
self.log_message("Client with address {0} and fingerprint"
471
" {1} could not be found"
472
.format(address, fingerprint))
501
self.log_message((u"Client with address %s and fingerprint %s"
502
u" could not be found" % (address,
503
fingerprint)))
473
504
474
505
def rebuild(self):
475
506
"""This rebuilds the User Interface.
485
516
self.divider)))
486
517
if self.log_visible:
487
518
self.uilist.append(self.logbox)
519
pass
488
520
self.topwidget = urwid.Pile(self.uilist)
489
521
490
522
def log_message(self, message):
491
"""Log message formatted with timestamp"""
492
523
timestamp = datetime.datetime.now().isoformat()
493
self.log_message_raw(timestamp + ": " + message)
524
self.log_message_raw(timestamp + u": " + message)
494
525
495
526
def log_message_raw(self, markup):
496
527
"""Add a log message to the log buffer."""
499
530
and len(self.log) > self.max_log_length):
500
531
del self.log[0:len(self.log)-self.max_log_length-1]
501
532
self.logbox.set_focus(len(self.logbox.body.contents),
502
coming_from="above")
533
coming_from=u"above")
503
534
self.refresh()
504
535
505
536
def toggle_log_display(self):
506
537
"""Toggle visibility of the log buffer."""
507
538
self.log_visible = not self.log_visible
508
539
self.rebuild()
509
#self.log_message("Log visibility changed to: "
510
# + str(self.log_visible))
540
#self.log_message(u"Log visibility changed to: "
541
# + unicode(self.log_visible))
511
542
512
543
def change_log_display(self):
513
544
"""Change type of log display.
514
545
Currently, this toggles wrapping of text lines."""
515
if self.log_wrap == "clip":
516
self.log_wrap = "any"
546
if self.log_wrap == u"clip":
547
self.log_wrap = u"any"
517
548
else:
518
self.log_wrap = "clip"
549
self.log_wrap = u"clip"
519
550
for textwidget in self.log:
520
551
textwidget.set_wrap_mode(self.log_wrap)
521
#self.log_message("Wrap mode: " + self.log_wrap)
552
#self.log_message(u"Wrap mode: " + self.log_wrap)
522
553
523
554
def find_and_remove_client(self, path, name):
524
"""Find a client by its object path and remove it.
555
"""Find an client from its object path and remove it.
525
556
526
557
This is connected to the ClientRemoved signal from the
527
558
Mandos server object."""
529
560
client = self.clients_dict[path]
530
561
except KeyError:
531
562
# not found?
532
self.log_message("Unknown client {0!r} ({1!r}) removed"
533
.format(name, path))
534
563
return
535
client.delete()
564
self.remove_client(client, path)
536
565
537
566
def add_new_client(self, path):
538
567
client_proxy_object = self.bus.get_object(self.busname, path)
553
582
if path is None:
554
583
path = client.proxy.object_path
555
584
self.clients_dict[path] = client
556
self.clients.sort(key=lambda c: c.properties["Name"])
585
self.clients.sort(None, lambda c: c.properties[u"Name"])
557
586
self.refresh()
558
587
559
588
def remove_client(self, client, path=None):
561
590
if path is None:
562
591
path = client.proxy.object_path
563
592
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()
564
598
self.refresh()
565
599
566
600
def refresh(self):
570
604
571
605
def run(self):
572
606
"""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
619
607
self.refresh()
620
608
self._input_callback_tag = (gobject.io_add_watch
621
609
(sys.stdin.fileno(),
631
619
632
620
def process_input(self, source, condition):
633
621
keys = self.screen.get_input()
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
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
643
631
}
644
632
for key in keys:
645
633
try:
647
635
except KeyError: # :-)
648
636
pass
649
637
650
if key == "q" or key == "Q":
638
if key == u"q" or key == u"Q":
651
639
self.stop()
652
640
break
653
elif key == "window resize":
641
elif key == u"window resize":
654
642
self.size = self.screen.get_cols_rows()
655
643
self.refresh()
656
elif key == "\f": # Ctrl-L
644
elif key == u"\f": # Ctrl-L
657
645
self.refresh()
658
elif key == "l" or key == "D":
646
elif key == u"l" or key == u"D":
659
647
self.toggle_log_display()
660
648
self.refresh()
661
elif key == "w" or key == "i":
649
elif key == u"w" or key == u"i":
662
650
self.change_log_display()
663
651
self.refresh()
664
elif key == "?" or key == "f1" or key == "esc":
652
elif key == u"?" or key == u"f1" or key == u"esc":
665
653
if not self.log_visible:
666
654
self.log_visible = True
667
655
self.rebuild()
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"))))
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"))))
686
674
self.refresh()
687
elif key == "tab":
675
elif key == u"tab":
688
676
if self.topwidget.get_focus() is self.logbox:
689
677
self.topwidget.set_focus(0)
690
678
else:
691
679
self.topwidget.set_focus(self.logbox)
692
680
self.refresh()
693
#elif (key == "end" or key == "meta >" or key == "G"
694
# or key == ">"):
681
#elif (key == u"end" or key == u"meta >" or key == u"G"
682
# or key == u">"):
695
683
# pass # xxx end-of-buffer
696
#elif (key == "home" or key == "meta <" or key == "g"
697
# or key == "<"):
684
#elif (key == u"home" or key == u"meta <" or key == u"g"
685
# or key == u"<"):
698
686
# pass # xxx beginning-of-buffer
699
#elif key == "ctrl e" or key == "$":
687
#elif key == u"ctrl e" or key == u"$":
700
688
# pass # xxx move-end-of-line
701
#elif key == "ctrl a" or key == "^":
689
#elif key == u"ctrl a" or key == u"^":
702
690
# pass # xxx move-beginning-of-line
703
#elif key == "ctrl b" or key == "meta (" or key == "h":
691
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
704
692
# pass # xxx left
705
#elif key == "ctrl f" or key == "meta )" or key == "l":
693
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
706
694
# pass # xxx right
707
#elif key == "a":
695
#elif key == u"a":
708
696
# pass # scroll up log
709
#elif key == "z":
697
#elif key == u"z":
710
698
# pass # scroll down log
711
699
elif self.topwidget.selectable():
712
700
self.topwidget.keypress(self.size, key)
718
706
ui.run()
719
707
except KeyboardInterrupt:
720
708
ui.screen.stop()
721
except Exception as e:
722
ui.log_message(str(e))
709
except Exception, e:
710
ui.log_message(unicode(e))
723
711
ui.screen.stop()
724
712
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0