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