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