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