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