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 779
- compare with another revision
- download diff
- download tarball
- view history from revision 779
- Committer: Teddy Hogeborn
- Date: 2015-07-27 09:23:56 UTC
- Revision ID: teddy@recompile.se-20150727092356-65ul6jsiozlkjw4e
Debian bug fix for mandos-client: Remove dhparams.pem on purge.
* debian/mandos-client.postrm (purge): Bug fix: Remove dhparams.pem.
* debian/mandos-client.postrm (purge): Bug fix: Remove dhparams.pem.
- 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-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
#
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
def checker_completed(self, exitstatus, condition, command):
176
def checker_completed(self, exitstatus, signal, 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
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))
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))
208
194
else:
209
self.logger(u'Checker for client %s completed'
210
u' mysteriously')
195
self.logger('Checker for client {} completed'
196
' mysteriously'
197
.format(self.properties["Name"]))
211
198
self.update()
212
199
213
200
def checker_started(self, command):
214
#self.logger(u'Client %s started checker "%s"'
215
# % (self.properties[u"Name"], unicode(command)))
216
pass
201
"""Server signals that a checker started."""
202
self.logger('Client {} started checker "{}"'
203
.format(self.properties["Name"],
204
command), level=0)
217
205
218
206
def got_secret(self):
219
self.last_checker_failed = False
220
self.logger(u'Client %s received its secret'
221
% self.properties[u"Name"])
207
self.logger('Client {} received its secret'
208
.format(self.properties["Name"]))
222
209
223
210
def need_approval(self, timeout, default):
224
211
if not default:
225
message = u'Client %s needs approval within %s seconds'
212
message = 'Client {} needs approval within {} seconds'
226
213
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)
214
message = 'Client {} will get its secret in {} seconds'
215
self.logger(message.format(self.properties["Name"],
216
timeout/1000))
231
217
232
218
def rejected(self, reason):
233
self.logger(u'Client %s was rejected; reason: %s'
234
% (self.properties[u"Name"], reason))
219
self.logger('Client {} was rejected; reason: {}'
220
.format(self.properties["Name"], reason))
235
221
236
222
def selectable(self):
237
223
"""Make this a "selectable" widget.
238
224
This overrides the method from urwid.FlowWidget."""
239
225
return True
240
226
241
def rows(self, (maxcol,), focus=False):
227
def rows(self, maxcolrow, focus=False):
242
228
"""How many rows this widget will occupy might depend on
243
229
whether we have focus or not.
244
230
This overrides the method from urwid.FlowWidget"""
245
return self.current_widget(focus).rows((maxcol,), focus=focus)
231
return self.current_widget(focus).rows(maxcolrow, focus=focus)
246
232
247
233
def current_widget(self, focus=False):
248
234
if focus or self.opened:
252
238
def update(self):
253
239
"Called when what is visible on the screen should be updated."
254
240
# 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",
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",
261
247
}
262
248
263
249
# Rebuild focus and non-focus widgets using current properties
264
250
265
251
# 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"]:
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"]:
271
257
timeout = datetime.timedelta(milliseconds
272
258
= self.properties
273
[u"ApprovalDelay"])
259
["ApprovalDelay"])
274
260
last_approval_request = isoformat_to_datetime(
275
self.properties[u"LastApprovalRequest"])
261
self.properties["LastApprovalRequest"])
276
262
if last_approval_request is not None:
277
timer = timeout - (datetime.datetime.utcnow()
278
- last_approval_request)
263
timer = max(timeout - (datetime.datetime.utcnow()
264
- last_approval_request),
265
datetime.timedelta())
279
266
else:
280
267
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])
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)
298
288
else:
299
message = u"enabled"
300
self._text = "%s%s" % (base, message)
301
289
message = "enabled"
290
self.using_timer(False)
291
self._text = "{}{}".format(base, message)
292
302
293
if not urwid.supports_unicode():
303
294
self._text = self._text.encode("ascii", "replace")
304
textlist = [(u"normal", self._text)]
295
textlist = [("normal", self._text)]
305
296
self._text_widget.set_text(textlist)
306
297
self._focus_text_widget.set_text([(with_standout[text[0]],
307
298
text[1])
316
307
self.update_hook()
317
308
318
309
def update_timer(self):
319
"called by gobject"
310
"""called by gobject. Will indefinitely loop until
311
gobject.source_remove() on tag is called"""
320
312
self.update()
321
313
return True # Keep calling this
322
314
323
def delete(self):
315
def delete(self, **kwargs):
324
316
if self._update_timer_callback_tag is not None:
325
317
gobject.source_remove(self._update_timer_callback_tag)
326
318
self._update_timer_callback_tag = None
319
for match in self.match_objects:
320
match.remove()
321
self.match_objects = ()
327
322
if self.delete_hook is not None:
328
323
self.delete_hook(self)
324
return super(MandosClientWidget, self).delete(**kwargs)
329
325
330
def render(self, (maxcol,), focus=False):
326
def render(self, maxcolrow, focus=False):
331
327
"""Render differently if we have focus.
332
328
This overrides the method from urwid.FlowWidget"""
333
return self.current_widget(focus).render((maxcol,),
329
return self.current_widget(focus).render(maxcolrow,
334
330
focus=focus)
335
331
336
def keypress(self, (maxcol,), key):
332
def keypress(self, maxcolrow, key):
337
333
"""Handle keys.
338
334
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":
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":
344
342
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
345
dbus_interface = client_interface)
346
elif key == u"d":
343
dbus_interface = client_interface,
344
ignore_reply=True)
345
elif key == "d":
347
346
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":
347
dbus_interface = client_interface,
348
ignore_reply=True)
349
elif key == "R" or key == "_" or key == "ctrl k":
350
350
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)
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)
358
362
# xxx
359
# elif key == u"p" or key == "=":
363
# elif key == "p" or key == "=":
360
364
# self.proxy.pause()
361
# elif key == u"u" or key == ":":
365
# elif key == "u" or key == ":":
362
366
# self.proxy.unpause()
363
# elif key == u"RET":
367
# elif key == "RET":
364
368
# self.open()
365
369
else:
366
370
return key
367
371
368
def property_changed(self, property=None, value=None,
369
*args, **kwargs):
370
"""Call self.update() if old value is not new value.
372
def properties_changed(self, interface, properties, invalidated):
373
"""Call self.update() if any properties changed.
371
374
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:
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):
377
381
self.update()
378
382
379
383
382
386
"down" key presses, thus not allowing any containing widgets to
383
387
use them as an excuse to shift focus away from this widget.
384
388
"""
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"):
389
def keypress(self, *args, **kwargs):
390
ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
391
if ret in ("up", "down"):
389
392
return
390
393
return ret
391
394
394
397
"""This is the entire user interface - the whole screen
395
398
with boxes, lists of client widgets, etc.
396
399
"""
397
def __init__(self, max_log_length=1000):
400
def __init__(self, max_log_length=1000, log_level=1):
398
401
DBusGMainLoop(set_as_default=True)
399
402
400
403
self.screen = urwid.curses_display.Screen()
401
404
402
405
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")),
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"),
420
424
))
421
425
422
426
if urwid.supports_unicode():
423
self.divider = u"─" # \u2500
424
#self.divider = u"━" # \u2501
427
self.divider = "─" # \u2500
428
#self.divider = "━" # \u2501
425
429
else:
426
#self.divider = u"-" # \u002d
427
self.divider = u"_" # \u005f
430
#self.divider = "-" # \u002d
431
self.divider = "_" # \u005f
428
432
429
433
self.screen.start()
430
434
437
441
self.log = []
438
442
self.max_log_length = max_log_length
439
443
444
self.log_level = log_level
445
440
446
# We keep a reference to the log widget so we can remove it
441
447
# from the ListWalker without it getting destroyed
442
448
self.logbox = ConstrainedListBox(self.log)
444
450
# This keeps track of whether self.uilist currently has
445
451
# self.logbox in it or not
446
452
self.log_visible = True
447
self.log_wrap = u"any"
453
self.log_wrap = "any"
448
454
449
455
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"))
456
self.log_message_raw(("bold",
457
"Mandos Monitor version " + version))
458
self.log_message_raw(("bold",
459
"q: Quit ?: Help"))
454
460
455
461
self.busname = domain + '.Mandos'
456
462
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
463
500
464
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)))
465
self.log_message("Client with address {} and fingerprint {}"
466
" could not be found"
467
.format(address, fingerprint))
504
468
505
469
def rebuild(self):
506
470
"""This rebuilds the User Interface.
516
480
self.divider)))
517
481
if self.log_visible:
518
482
self.uilist.append(self.logbox)
519
pass
520
483
self.topwidget = urwid.Pile(self.uilist)
521
484
522
def log_message(self, message):
485
def log_message(self, message, level=1):
486
"""Log message formatted with timestamp"""
487
if level < self.log_level:
488
return
523
489
timestamp = datetime.datetime.now().isoformat()
524
self.log_message_raw(timestamp + u": " + message)
490
self.log_message_raw("{}: {}".format(timestamp, message),
491
level=level)
525
492
526
def log_message_raw(self, markup):
493
def log_message_raw(self, markup, level=1):
527
494
"""Add a log message to the log buffer."""
495
if level < self.log_level:
496
return
528
497
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
529
498
if (self.max_log_length
530
499
and len(self.log) > self.max_log_length):
531
500
del self.log[0:len(self.log)-self.max_log_length-1]
532
501
self.logbox.set_focus(len(self.logbox.body.contents),
533
coming_from=u"above")
502
coming_from="above")
534
503
self.refresh()
535
504
536
505
def toggle_log_display(self):
537
506
"""Toggle visibility of the log buffer."""
538
507
self.log_visible = not self.log_visible
539
508
self.rebuild()
540
#self.log_message(u"Log visibility changed to: "
541
# + unicode(self.log_visible))
509
self.log_message("Log visibility changed to: {}"
510
.format(self.log_visible), level=0)
542
511
543
512
def change_log_display(self):
544
513
"""Change type of log display.
545
514
Currently, this toggles wrapping of text lines."""
546
if self.log_wrap == u"clip":
547
self.log_wrap = u"any"
515
if self.log_wrap == "clip":
516
self.log_wrap = "any"
548
517
else:
549
self.log_wrap = u"clip"
518
self.log_wrap = "clip"
550
519
for textwidget in self.log:
551
520
textwidget.set_wrap_mode(self.log_wrap)
552
#self.log_message(u"Wrap mode: " + self.log_wrap)
521
self.log_message("Wrap mode: {}".format(self.log_wrap),
522
level=0)
553
523
554
524
def find_and_remove_client(self, path, name):
555
"""Find an client from its object path and remove it.
525
"""Find a client by its object path and remove it.
556
526
557
527
This is connected to the ClientRemoved signal from the
558
528
Mandos server object."""
560
530
client = self.clients_dict[path]
561
531
except KeyError:
562
532
# not found?
533
self.log_message("Unknown client {!r} ({!r}) removed"
534
.format(name, path))
563
535
return
564
self.remove_client(client, path)
536
client.delete()
565
537
566
538
def add_new_client(self, path):
567
539
client_proxy_object = self.bus.get_object(self.busname, path)
582
554
if path is None:
583
555
path = client.proxy.object_path
584
556
self.clients_dict[path] = client
585
self.clients.sort(None, lambda c: c.properties[u"Name"])
557
self.clients.sort(key=lambda c: c.properties["Name"])
586
558
self.refresh()
587
559
588
560
def remove_client(self, client, path=None):
590
562
if path is None:
591
563
path = client.proxy.object_path
592
564
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
565
self.refresh()
599
566
600
567
def refresh(self):
604
571
605
572
def run(self):
606
573
"""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
607
620
self.refresh()
608
621
self._input_callback_tag = (gobject.io_add_watch
609
622
(sys.stdin.fileno(),
619
632
620
633
def process_input(self, source, condition):
621
634
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
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
631
644
}
632
645
for key in keys:
633
646
try:
635
648
except KeyError: # :-)
636
649
pass
637
650
638
if key == u"q" or key == u"Q":
651
if key == "q" or key == "Q":
639
652
self.stop()
640
653
break
641
elif key == u"window resize":
654
elif key == "window resize":
642
655
self.size = self.screen.get_cols_rows()
643
656
self.refresh()
644
elif key == u"\f": # Ctrl-L
657
elif key == "ctrl l":
658
self.screen.clear()
645
659
self.refresh()
646
elif key == u"l" or key == u"D":
660
elif key == "l" or key == "D":
647
661
self.toggle_log_display()
648
662
self.refresh()
649
elif key == u"w" or key == u"i":
663
elif key == "w" or key == "i":
650
664
self.change_log_display()
651
665
self.refresh()
652
elif key == u"?" or key == u"f1" or key == u"esc":
666
elif key == "?" or key == "f1" or key == "esc":
653
667
if not self.log_visible:
654
668
self.log_visible = True
655
669
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"))))
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"))))
674
690
self.refresh()
675
elif key == u"tab":
691
elif key == "tab":
676
692
if self.topwidget.get_focus() is self.logbox:
677
693
self.topwidget.set_focus(0)
678
694
else:
679
695
self.topwidget.set_focus(self.logbox)
680
696
self.refresh()
681
#elif (key == u"end" or key == u"meta >" or key == u"G"
682
# or key == u">"):
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 == ">"):
683
706
# pass # xxx end-of-buffer
684
#elif (key == u"home" or key == u"meta <" or key == u"g"
685
# or key == u"<"):
707
#elif (key == "home" or key == "meta <" or key == "g"
708
# or key == "<"):
686
709
# pass # xxx beginning-of-buffer
687
#elif key == u"ctrl e" or key == u"$":
710
#elif key == "ctrl e" or key == "$":
688
711
# pass # xxx move-end-of-line
689
#elif key == u"ctrl a" or key == u"^":
712
#elif key == "ctrl a" or key == "^":
690
713
# pass # xxx move-beginning-of-line
691
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
714
#elif key == "ctrl b" or key == "meta (" or key == "h":
692
715
# pass # xxx left
693
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
716
#elif key == "ctrl f" or key == "meta )" or key == "l":
694
717
# pass # xxx right
695
#elif key == u"a":
718
#elif key == "a":
696
719
# pass # scroll up log
697
#elif key == u"z":
720
#elif key == "z":
698
721
# pass # scroll down log
699
722
elif self.topwidget.selectable():
700
723
self.topwidget.keypress(self.size, key)
706
729
ui.run()
707
730
except KeyboardInterrupt:
708
731
ui.screen.stop()
709
except Exception, e:
710
ui.log_message(unicode(e))
732
except Exception as e:
733
ui.log_message(str(e))
711
734
ui.screen.stop()
712
735
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0