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 1241
- compare with another revision
- download diff
- download tarball
- view history from revision 1241
- Committer: Teddy Hogeborn
- Date: 2021-03-21 18:48:43 UTC
- Revision ID: teddy@recompile.se-20210321184843-va7cywxnlf31tbyt
Break long line (white space change only)
* plugin-runner.c (main): Break long line.
* plugin-runner.c (main): Break long line.
- 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.6.0"
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.14"
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
"""Log message formatted with timestamp"""
493
timestamp = datetime.datetime.now().isoformat()
494
self.log_message_raw(timestamp + ": " + message)
495
496
def log_message_raw(self, markup):
497
"""Add a log message to the log buffer."""
494
495
def add_log_line(self, markup):
498
496
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
499
if (self.max_log_length
500
and len(self.log) > self.max_log_length):
501
del self.log[0:len(self.log)-self.max_log_length-1]
502
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,
503
501
coming_from="above")
504
502
self.refresh()
505
503
506
504
def toggle_log_display(self):
507
505
"""Toggle visibility of the log buffer."""
508
506
self.log_visible = not self.log_visible
509
507
self.rebuild()
510
#self.log_message("Log visibility changed to: "
511
# + unicode(self.log_visible))
512
508
log.debug("Log visibility changed to: %s", self.log_visible)
509
513
510
def change_log_display(self):
514
511
"""Change type of log display.
515
512
Currently, this toggles wrapping of text lines."""
519
516
self.log_wrap = "clip"
520
517
for textwidget in self.log:
521
518
textwidget.set_wrap_mode(self.log_wrap)
522
#self.log_message("Wrap mode: " + self.log_wrap)
523
524
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):
525
522
"""Find a client by its object path and remove it.
526
527
This is connected to the ClientRemoved signal from the
523
524
This is connected to the InterfacesRemoved signal from the
528
525
Mandos server object."""
526
if client_interface not in interfaces:
527
# Not a Mandos client object; ignore
528
return
529
529
try:
530
530
client = self.clients_dict[path]
531
531
except KeyError:
532
532
# not found?
533
self.log_message("Unknown client {0!r} ({1!r}) removed"
534
.format(name, path))
533
log.warning("Unknown client %s removed", path)
535
534
return
536
535
client.delete()
537
538
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
539
546
client_proxy_object = self.bus.get_object(self.busname, path)
540
self.add_client(MandosClientWidget(server_proxy_object
541
=self.mandos_serv,
542
proxy_object
543
=client_proxy_object,
544
update_hook
545
=self.refresh,
546
delete_hook
547
=self.remove_client,
548
logger
549
=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])),
550
553
path=path)
551
554
552
555
def add_client(self, client, path=None):
553
556
self.clients.append(client)
554
557
if path is None:
555
558
path = client.proxy.object_path
556
559
self.clients_dict[path] = client
557
self.clients.sort(None, lambda c: c.properties["Name"])
560
self.clients.sort(key=lambda c: c.properties["Name"])
558
561
self.refresh()
559
562
560
563
def remove_client(self, client, path=None):
561
564
self.clients.remove(client)
562
565
if path is None:
563
566
path = client.proxy.object_path
564
567
del self.clients_dict[path]
565
if not self.clients_dict:
566
# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
567
# is completely emptied, we need to recreate it.
568
self.clients = urwid.SimpleListWalker([])
569
self.rebuild()
570
568
self.refresh()
571
569
572
570
def refresh(self):
573
571
"""Redraw the screen"""
574
572
canvas = self.topwidget.render(self.size, focus=True)
575
573
self.screen.draw_screen(self.size, canvas)
576
574
577
575
def run(self):
578
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")
579
582
self.bus = dbus.SystemBus()
580
583
mandos_dbus_objc = self.bus.get_object(
581
584
self.busname, "/", follow_name_owner_changes=True)
582
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
583
dbus_interface
584
= server_interface)
585
self.mandos_serv = dbus.Interface(
586
mandos_dbus_objc, dbus_interface=server_interface)
585
587
try:
586
588
mandos_clients = (self.mandos_serv
587
589
.GetAllClientsWithProperties())
588
590
if not mandos_clients:
589
self.log_message_raw(("bold", "Note: Server has no clients."))
591
log.warning("Note: Server has no clients.")
590
592
except dbus.exceptions.DBusException:
591
self.log_message_raw(("bold", "Note: No Mandos servers running."))
593
log.warning("Note: No Mandos server running.")
592
594
mandos_clients = dbus.Dictionary()
593
595
594
596
(self.mandos_serv
595
.connect_to_signal("ClientRemoved",
597
.connect_to_signal("InterfacesRemoved",
596
598
self.find_and_remove_client,
597
dbus_interface=server_interface,
599
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
598
600
byte_arrays=True))
599
601
(self.mandos_serv
600
.connect_to_signal("ClientAdded",
602
.connect_to_signal("InterfacesAdded",
601
603
self.add_new_client,
602
dbus_interface=server_interface,
604
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
603
605
byte_arrays=True))
604
606
(self.mandos_serv
605
607
.connect_to_signal("ClientNotFound",
606
608
self.client_not_found,
607
609
dbus_interface=server_interface,
608
610
byte_arrays=True))
609
for path, client in mandos_clients.iteritems():
611
for path, client in mandos_clients.items():
610
612
client_proxy_object = self.bus.get_object(self.busname,
611
613
path)
612
self.add_client(MandosClientWidget(server_proxy_object
613
=self.mandos_serv,
614
proxy_object
615
=client_proxy_object,
616
properties=client,
617
update_hook
618
=self.refresh,
619
delete_hook
620
=self.remove_client,
621
logger
622
=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),
623
620
path=path)
624
621
625
622
self.refresh()
626
self._input_callback_tag = (gobject.io_add_watch
627
(sys.stdin.fileno(),
628
gobject.IO_IN,
629
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)))
630
628
self.main_loop.run()
631
629
# Main loop has finished, we should close everything now
632
gobject.source_remove(self._input_callback_tag)
633
self.screen.stop()
634
630
GLib.source_remove(self._input_callback_tag)
631
with warnings.catch_warnings():
632
warnings.simplefilter("ignore", BytesWarning)
633
self.screen.stop()
634
635
635
def stop(self):
636
636
self.main_loop.quit()
637
637
log.removeHandler(self.loghandler)
638
log.propagate = self.orig_log_propagate
639
638
640
def process_input(self, source, condition):
639
641
keys = self.screen.get_input()
640
translations = { "ctrl n": "down", # Emacs
641
"ctrl p": "up", # Emacs
642
"ctrl v": "page down", # Emacs
643
"meta v": "page up", # Emacs
644
" ": "page down", # less
645
"f": "page down", # less
646
"b": "page up", # less
647
"j": "down", # vi
648
"k": "up", # vi
649
}
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
}
650
652
for key in keys:
651
653
try:
652
654
key = translations[key]
653
655
except KeyError: # :-)
654
656
pass
655
657
656
658
if key == "q" or key == "Q":
657
659
self.stop()
658
660
break
659
661
elif key == "window resize":
660
662
self.size = self.screen.get_cols_rows()
661
663
self.refresh()
662
elif key == "\f": # Ctrl-L
664
elif key == "ctrl l":
665
self.screen.clear()
663
666
self.refresh()
664
667
elif key == "l" or key == "D":
665
668
self.toggle_log_display()
671
674
if not self.log_visible:
672
675
self.log_visible = True
673
676
self.rebuild()
674
self.log_message_raw(("bold",
675
" ".
676
join(("q: Quit",
677
"?: Help",
678
"l: Log window toggle",
679
"TAB: Switch window",
680
"w: Wrap (log)"))))
681
self.log_message_raw(("bold",
682
" "
683
.join(("Clients:",
684
"+: Enable",
685
"-: Disable",
686
"R: Remove",
687
"s: Start new checker",
688
"S: Stop checker",
689
"C: Checker OK",
690
"a: Approve",
691
"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
))))
692
696
self.refresh()
693
697
elif key == "tab":
694
698
if self.topwidget.get_focus() is self.logbox:
696
700
else:
697
701
self.topwidget.set_focus(self.logbox)
698
702
self.refresh()
699
#elif (key == "end" or key == "meta >" or key == "G"
700
# or key == ">"):
701
# pass # xxx end-of-buffer
702
#elif (key == "home" or key == "meta <" or key == "g"
703
# or key == "<"):
704
# pass # xxx beginning-of-buffer
705
#elif key == "ctrl e" or key == "$":
706
# pass # xxx move-end-of-line
707
#elif key == "ctrl a" or key == "^":
708
# pass # xxx move-beginning-of-line
709
#elif key == "ctrl b" or key == "meta (" or key == "h":
710
# pass # xxx left
711
#elif key == "ctrl f" or key == "meta )" or key == "l":
712
# pass # xxx right
713
#elif key == "a":
714
# pass # scroll up log
715
#elif key == "z":
716
# 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
717
728
elif self.topwidget.selectable():
718
729
self.topwidget.keypress(self.size, key)
719
730
self.refresh()
720
731
return True
721
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
722
747
ui = UserInterface()
723
748
try:
724
749
ui.run()
725
750
except KeyboardInterrupt:
726
ui.screen.stop()
727
except Exception, e:
728
ui.log_message(unicode(e))
729
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()
730
758
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0