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