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