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