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