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