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 589
- compare with another revision
- download diff
- download tarball
- view history from revision 589
- Committer: Teddy Hogeborn
- Date: 2012-05-25 15:59:39 UTC
- Revision ID: teddy@recompile.se-20120525155939-bg6ricuff86zsjgx
* network-hooks.d/wireless: Read from config file, so don't run "env".
- files added:
- initramfs-tools-hook-conf
- files removed:
- bugs.xml
- debian/tests
- debian/upstream
- dracut-module
- plugin-helpers
- files modified:
- .bzrignore
added
removed
mandos-monitor
1
#!/usr/bin/python3 -bbI
1
#!/usr/bin/python
2
2
# -*- mode: python; coding: utf-8 -*-
3
#
3
#
4
4
# Mandos Monitor - Control and monitor the Mandos server
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
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
13
11
# the Free Software Foundation, either version 3 of the License, or
14
12
# (at your option) any later version.
15
13
#
16
# Mandos is distributed in the hope that it will be useful, but
17
# WITHOUT ANY WARRANTY; without even the implied warranty of
14
# This program is distributed in the hope that it will be useful,
15
# but WITHOUT ANY WARRANTY; without even the implied warranty of
18
16
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19
17
# GNU General Public License for more details.
20
#
18
#
21
19
# You should have received a copy of the GNU General Public License
22
# along with Mandos. If not, see <http://www.gnu.org/licenses/>.
23
#
20
# along with this program. If not, see
21
# <http://www.gnu.org/licenses/>.
22
#
24
23
# Contact the authors at <mandos@recompile.se>.
25
#
24
#
26
25
27
26
from __future__ import (division, absolute_import, print_function,
28
27
unicode_literals)
29
try:
30
from future_builtins import *
31
except ImportError:
32
pass
28
29
from future_builtins import *
33
30
34
31
import sys
35
32
import os
36
import warnings
33
import signal
34
37
35
import datetime
38
import locale
39
import logging
40
36
41
37
import urwid.curses_display
42
38
import urwid
43
39
44
40
from dbus.mainloop.glib import DBusGMainLoop
45
from gi.repository import GLib
41
import gobject
46
42
47
43
import dbus
48
44
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)
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)
62
53
63
54
# Some useful constants
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
55
domain = 'se.recompile'
56
server_interface = domain + '.Mandos'
57
client_interface = domain + '.Mandos.Client'
58
version = "1.5.4"
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)
74
67
75
68
def isoformat_to_datetime(iso):
76
69
"Parse an ISO 8601 date string to a datetime.datetime()"
85
78
int(day),
86
79
int(hour),
87
80
int(minute),
88
int(second), # Whole seconds
89
int(fraction*1000000)) # Microseconds
90
91
92
class MandosClientPropertyCache:
81
int(second), # Whole seconds
82
int(fraction*1000000)) # Microseconds
83
84
class MandosClientPropertyCache(object):
93
85
"""This wraps a Mandos Client D-Bus proxy object, caches the
94
86
properties and calls a hook function when any of them are
95
87
changed.
96
88
"""
97
89
def __init__(self, proxy_object=None, properties=None, **kwargs):
98
self.proxy = proxy_object # Mandos Client proxy object
90
self.proxy = proxy_object # Mandos Client proxy object
99
91
self.properties = dict() if properties is None else properties
100
92
self.property_changed_match = (
101
self.proxy.connect_to_signal("PropertiesChanged",
102
self.properties_changed,
103
dbus.PROPERTIES_IFACE,
93
self.proxy.connect_to_signal("PropertyChanged",
94
self._property_changed,
95
client_interface,
104
96
byte_arrays=True))
105
97
106
98
if properties is None:
107
self.properties.update(self.proxy.GetAll(
108
client_interface,
109
dbus_interface=dbus.PROPERTIES_IFACE))
110
99
self.properties.update(
100
self.proxy.GetAll(client_interface,
101
dbus_interface
102
= dbus.PROPERTIES_IFACE))
103
111
104
super(MandosClientPropertyCache, self).__init__(**kwargs)
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.
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.
116
113
"""
117
114
# Update properties dict with new value
118
if interface == client_interface:
119
self.properties.update(properties)
120
115
self.properties[property] = value
116
121
117
def delete(self):
122
118
self.property_changed_match.remove()
123
119
125
121
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
126
122
"""A Mandos Client which is visible on the screen.
127
123
"""
128
124
129
125
def __init__(self, server_proxy_object=None, update_hook=None,
130
delete_hook=None, **kwargs):
126
delete_hook=None, logger=None, **kwargs):
131
127
# Called on update
132
128
self.update_hook = update_hook
133
129
# Called on delete
134
130
self.delete_hook = delete_hook
135
131
# Mandos Server proxy object
136
132
self.server_proxy_object = server_proxy_object
137
133
# Logger
134
self.logger = logger
135
138
136
self._update_timer_callback_tag = None
139
137
140
138
# The widget shown normally
141
139
self._text_widget = urwid.Text("")
142
140
# The widget shown when we have focus
144
142
super(MandosClientWidget, self).__init__(**kwargs)
145
143
self.update()
146
144
self.opened = False
147
145
148
146
self.match_objects = (
149
147
self.proxy.connect_to_signal("CheckerCompleted",
150
148
self.checker_completed,
166
164
self.rejected,
167
165
client_interface,
168
166
byte_arrays=True))
169
log.debug("Created client %s", self.properties["Name"])
170
167
#self.logger('Created client {0}'
168
# .format(self.properties["Name"]))
169
171
170
def using_timer(self, flag):
172
171
"""Call this method with True or False when timer should be
173
172
activated or deactivated.
174
173
"""
175
174
if flag and self._update_timer_callback_tag is None:
176
175
# Will update the shown timer value every second
177
self._update_timer_callback_tag = (
178
GLib.timeout_add(1000,
179
glib_safely(self.update_timer)))
176
self._update_timer_callback_tag = (gobject.timeout_add
177
(1000,
178
self.update_timer))
180
179
elif not (flag or self._update_timer_callback_tag is None):
181
GLib.source_remove(self._update_timer_callback_tag)
180
gobject.source_remove(self._update_timer_callback_tag)
182
181
self._update_timer_callback_tag = None
183
182
184
183
def checker_completed(self, exitstatus, condition, command):
185
184
if exitstatus == 0:
186
log.debug('Checker for client %s (command "%s")'
187
" succeeded", self.properties["Name"], command)
188
185
self.update()
189
186
return
190
187
# Checker failed
191
188
if os.WIFEXITED(condition):
192
log.info('Checker for client %s (command "%s") failed'
193
" with exit code %d", self.properties["Name"],
194
command, os.WEXITSTATUS(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)))
195
193
elif os.WIFSIGNALED(condition):
196
log.info('Checker for client %s (command "%s") was'
197
" killed by signal %d", self.properties["Name"],
198
command, os.WTERMSIG(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"]))
199
206
self.update()
200
207
201
208
def checker_started(self, command):
202
"""Server signals that a checker started."""
203
log.debug('Client %s started checker "%s"',
204
self.properties["Name"], command)
205
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
206
216
def got_secret(self):
207
log.info("Client %s received its secret",
208
self.properties["Name"])
209
217
self.logger('Client {0} received its secret'
218
.format(self.properties["Name"]))
219
210
220
def need_approval(self, timeout, default):
211
221
if not default:
212
message = "Client %s needs approval within %f seconds"
222
message = 'Client {0} needs approval within {1} seconds'
213
223
else:
214
message = "Client %s will get its secret in %f seconds"
215
log.info(message, self.properties["Name"], timeout/1000)
216
224
message = 'Client {0} will get its secret in {1} seconds'
225
self.logger(message.format(self.properties["Name"],
226
timeout/1000))
227
217
228
def rejected(self, reason):
218
log.info("Client %s was rejected; reason: %s",
219
self.properties["Name"], reason)
220
229
self.logger('Client {0} was rejected; reason: {1}'
230
.format(self.properties["Name"], reason))
231
221
232
def selectable(self):
222
233
"""Make this a "selectable" widget.
223
234
This overrides the method from urwid.FlowWidget."""
224
235
return True
225
236
226
237
def rows(self, maxcolrow, focus=False):
227
238
"""How many rows this widget will occupy might depend on
228
239
whether we have focus or not.
229
240
This overrides the method from urwid.FlowWidget"""
230
241
return self.current_widget(focus).rows(maxcolrow, focus=focus)
231
242
232
243
def current_widget(self, focus=False):
233
244
if focus or self.opened:
234
245
return self._focus_widget
235
246
return self._widget
236
247
237
248
def update(self):
238
249
"Called when what is visible on the screen should be updated."
239
250
# How to add standout mode to a style
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
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
248
259
# Rebuild focus and non-focus widgets using current properties
249
260
250
261
# Base part of a client. Name!
251
base = "{name}: ".format(name=self.properties["Name"])
262
base = '{name}: '.format(name=self.properties["Name"])
252
263
if not self.properties["Enabled"]:
253
264
message = "DISABLED"
254
265
self.using_timer(False)
255
266
elif self.properties["ApprovalPending"]:
256
timeout = datetime.timedelta(
257
milliseconds=self.properties["ApprovalDelay"])
267
timeout = datetime.timedelta(milliseconds
268
= self.properties
269
["ApprovalDelay"])
258
270
last_approval_request = isoformat_to_datetime(
259
271
self.properties["LastApprovalRequest"])
260
272
if last_approval_request is not None:
264
276
else:
265
277
timer = datetime.timedelta()
266
278
if self.properties["ApprovedByDefault"]:
267
message = "Approval in {}. (d)eny?"
279
message = "Approval in {0}. (d)eny?"
268
280
else:
269
message = "Denial in {}. (a)pprove?"
270
message = message.format(str(timer).rsplit(".", 1)[0])
281
message = "Denial in {0}. (a)pprove?"
282
message = message.format(unicode(timer).rsplit(".", 1)[0])
271
283
self.using_timer(True)
272
284
elif self.properties["LastCheckerStatus"] != 0:
273
285
# When checker has failed, show timer until client expires
276
288
timer = datetime.timedelta(0)
277
289
else:
278
290
expires = (datetime.datetime.strptime
279
(expires, "%Y-%m-%dT%H:%M:%S.%f"))
291
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
280
292
timer = max(expires - datetime.datetime.utcnow(),
281
293
datetime.timedelta())
282
message = ("A checker has failed! Time until client"
283
" gets disabled: {}"
284
.format(str(timer).rsplit(".", 1)[0]))
294
message = ('A checker has failed! Time until client'
295
' gets disabled: {0}'
296
.format(unicode(timer).rsplit(".", 1)[0]))
285
297
self.using_timer(True)
286
298
else:
287
299
message = "enabled"
288
300
self.using_timer(False)
289
self._text = "{}{}".format(base, message)
290
301
self._text = "{0}{1}".format(base, message)
302
291
303
if not urwid.supports_unicode():
292
304
self._text = self._text.encode("ascii", "replace")
293
305
textlist = [("normal", self._text)]
303
315
# Run update hook, if any
304
316
if self.update_hook is not None:
305
317
self.update_hook()
306
318
307
319
def update_timer(self):
308
"""called by GLib. Will indefinitely loop until
309
GLib.source_remove() on tag is called
310
"""
320
"""called by gobject. Will indefinitely loop until
321
gobject.source_remove() on tag is called"""
311
322
self.update()
312
323
return True # Keep calling this
313
324
314
325
def delete(self, **kwargs):
315
326
if self._update_timer_callback_tag is not None:
316
GLib.source_remove(self._update_timer_callback_tag)
327
gobject.source_remove(self._update_timer_callback_tag)
317
328
self._update_timer_callback_tag = None
318
329
for match in self.match_objects:
319
330
match.remove()
321
332
if self.delete_hook is not None:
322
333
self.delete_hook(self)
323
334
return super(MandosClientWidget, self).delete(**kwargs)
324
335
325
336
def render(self, maxcolrow, focus=False):
326
337
"""Render differently if we have focus.
327
338
This overrides the method from urwid.FlowWidget"""
328
339
return self.current_widget(focus).render(maxcolrow,
329
340
focus=focus)
330
341
331
342
def keypress(self, maxcolrow, key):
332
343
"""Handle keys.
333
344
This overrides the method from urwid.FlowWidget"""
334
345
if key == "+":
335
self.proxy.Set(client_interface, "Enabled",
336
dbus.Boolean(True), ignore_reply=True,
337
dbus_interface=dbus.PROPERTIES_IFACE)
346
self.proxy.Enable(dbus_interface = client_interface,
347
ignore_reply=True)
338
348
elif key == "-":
339
self.proxy.Set(client_interface, "Enabled", False,
340
ignore_reply=True,
341
dbus_interface=dbus.PROPERTIES_IFACE)
349
self.proxy.Disable(dbus_interface = client_interface,
350
ignore_reply=True)
342
351
elif key == "a":
343
352
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
344
dbus_interface=client_interface,
353
dbus_interface = client_interface,
345
354
ignore_reply=True)
346
355
elif key == "d":
347
356
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
348
dbus_interface=client_interface,
357
dbus_interface = client_interface,
349
358
ignore_reply=True)
350
359
elif key == "R" or key == "_" or key == "ctrl k":
351
360
self.server_proxy_object.RemoveClient(self.proxy
352
361
.object_path,
353
362
ignore_reply=True)
354
363
elif key == "s":
355
self.proxy.Set(client_interface, "CheckerRunning",
356
dbus.Boolean(True), ignore_reply=True,
357
dbus_interface=dbus.PROPERTIES_IFACE)
364
self.proxy.StartChecker(dbus_interface = client_interface,
365
ignore_reply=True)
358
366
elif key == "S":
359
self.proxy.Set(client_interface, "CheckerRunning",
360
dbus.Boolean(False), ignore_reply=True,
361
dbus_interface=dbus.PROPERTIES_IFACE)
367
self.proxy.StopChecker(dbus_interface = client_interface,
368
ignore_reply=True)
362
369
elif key == "C":
363
self.proxy.CheckedOK(dbus_interface=client_interface,
370
self.proxy.CheckedOK(dbus_interface = client_interface,
364
371
ignore_reply=True)
365
372
# xxx
366
373
# elif key == "p" or key == "=":
371
378
# self.open()
372
379
else:
373
380
return key
374
375
def properties_changed(self, interface, properties, invalidated):
376
"""Call self.update() if any properties changed.
381
382
def property_changed(self, property=None, **kwargs):
383
"""Call self.update() if old value is not new value.
377
384
This overrides the method from MandosClientPropertyCache"""
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):
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:
384
390
self.update()
385
391
386
392
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
397
393
class ConstrainedListBox(urwid.ListBox):
398
394
"""Like a normal urwid.ListBox, but will consume all "up" or
399
395
"down" key presses, thus not allowing any containing widgets to
400
396
use them as an excuse to shift focus away from this widget.
401
397
"""
402
398
def keypress(self, *args, **kwargs):
403
ret = (super(ConstrainedListBox, self)
404
.keypress(*args, **kwargs))
399
ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
405
400
if ret in ("up", "down"):
406
401
return
407
402
return ret
408
403
409
404
410
class UserInterface:
405
class UserInterface(object):
411
406
"""This is the entire user interface - the whole screen
412
407
with boxes, lists of client widgets, etc.
413
408
"""
414
409
def __init__(self, max_log_length=1000):
415
410
DBusGMainLoop(set_as_default=True)
416
411
417
412
self.screen = urwid.curses_display.Screen()
418
413
419
414
self.screen.register_palette((
420
415
("normal",
421
416
"default", "default", None),
422
417
("bold",
423
"bold", "default", "bold"),
418
"default", "default", "bold"),
424
419
("underline-blink",
425
"underline,blink", "default", "underline,blink"),
420
"default", "default", "underline"),
426
421
("standout",
427
"standout", "default", "standout"),
422
"default", "default", "standout"),
428
423
("bold-underline-blink",
429
"bold,underline,blink", "default",
430
"bold,underline,blink"),
424
"default", "default", ("bold", "underline")),
431
425
("bold-standout",
432
"bold,standout", "default", "bold,standout"),
426
"default", "default", ("bold", "standout")),
433
427
("underline-blink-standout",
434
"underline,blink,standout", "default",
435
"underline,blink,standout"),
428
"default", "default", ("underline", "standout")),
436
429
("bold-underline-blink-standout",
437
"bold,underline,blink,standout", "default",
438
"bold,underline,blink,standout"),
430
"default", "default", ("bold", "underline",
431
"standout")),
439
432
))
440
433
441
434
if urwid.supports_unicode():
442
self.divider = "─" # \u2500
435
self.divider = "─" # \u2500
436
#self.divider = "━" # \u2501
443
437
else:
444
self.divider = "_" # \u005f
445
438
#self.divider = "-" # \u002d
439
self.divider = "_" # \u005f
440
446
441
self.screen.start()
447
442
448
443
self.size = self.screen.get_cols_rows()
449
444
450
445
self.clients = urwid.SimpleListWalker([])
451
446
self.clients_dict = {}
452
447
453
448
# We will add Text widgets to this list
454
self.log = urwid.SimpleListWalker([])
449
self.log = []
455
450
self.max_log_length = max_log_length
456
451
457
452
# We keep a reference to the log widget so we can remove it
458
453
# from the ListWalker without it getting destroyed
459
454
self.logbox = ConstrainedListBox(self.log)
460
455
461
456
# This keeps track of whether self.uilist currently has
462
457
# self.logbox in it or not
463
458
self.log_visible = True
464
459
self.log_wrap = "any"
465
466
self.loghandler = UILogHandler(self)
467
460
468
461
self.rebuild()
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
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
480
475
def rebuild(self):
481
476
"""This rebuilds the User Interface.
482
477
Call this when the widget layout needs to change"""
483
478
self.uilist = []
484
# self.uilist.append(urwid.ListBox(self.clients))
479
#self.uilist.append(urwid.ListBox(self.clients))
485
480
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
486
481
clients),
487
# header=urwid.Divider(),
482
#header=urwid.Divider(),
488
483
header=None,
489
footer=urwid.Divider(
490
div_char=self.divider)))
484
footer=
485
urwid.Divider(div_char=
486
self.divider)))
491
487
if self.log_visible:
492
488
self.uilist.append(self.logbox)
493
489
self.topwidget = urwid.Pile(self.uilist)
494
495
def add_log_line(self, markup):
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."""
496
497
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
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,
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),
501
502
coming_from="above")
502
503
self.refresh()
503
504
504
505
def toggle_log_display(self):
505
506
"""Toggle visibility of the log buffer."""
506
507
self.log_visible = not self.log_visible
507
508
self.rebuild()
508
log.debug("Log visibility changed to: %s", self.log_visible)
509
509
#self.log_message("Log visibility changed to: "
510
# + unicode(self.log_visible))
511
510
512
def change_log_display(self):
511
513
"""Change type of log display.
512
514
Currently, this toggles wrapping of text lines."""
516
518
self.log_wrap = "clip"
517
519
for textwidget in self.log:
518
520
textwidget.set_wrap_mode(self.log_wrap)
519
log.debug("Wrap mode: %s", self.log_wrap)
520
521
def find_and_remove_client(self, path, interfaces):
521
#self.log_message("Wrap mode: " + self.log_wrap)
522
523
def find_and_remove_client(self, path, name):
522
524
"""Find a client by its object path and remove it.
523
524
This is connected to the InterfacesRemoved signal from the
525
526
This is connected to the ClientRemoved signal from the
525
527
Mandos server object."""
526
if client_interface not in interfaces:
527
# Not a Mandos client object; ignore
528
return
529
528
try:
530
529
client = self.clients_dict[path]
531
530
except KeyError:
532
531
# not found?
533
log.warning("Unknown client %s removed", path)
532
self.log_message("Unknown client {0!r} ({1!r}) removed"
533
.format(name, path))
534
534
return
535
535
client.delete()
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
536
537
def add_new_client(self, path):
546
538
client_proxy_object = self.bus.get_object(self.busname, path)
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])),
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),
553
549
path=path)
554
550
555
551
def add_client(self, client, path=None):
556
552
self.clients.append(client)
557
553
if path is None:
558
554
path = client.proxy.object_path
559
555
self.clients_dict[path] = client
560
self.clients.sort(key=lambda c: c.properties["Name"])
556
self.clients.sort(None, lambda c: c.properties["Name"])
561
557
self.refresh()
562
558
563
559
def remove_client(self, client, path=None):
564
560
self.clients.remove(client)
565
561
if path is None:
566
562
path = client.proxy.object_path
567
563
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()
568
569
self.refresh()
569
570
570
571
def refresh(self):
571
572
"""Redraw the screen"""
572
573
canvas = self.topwidget.render(self.size, focus=True)
573
574
self.screen.draw_screen(self.size, canvas)
574
575
575
576
def run(self):
576
577
"""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")
582
578
self.bus = dbus.SystemBus()
583
579
mandos_dbus_objc = self.bus.get_object(
584
580
self.busname, "/", follow_name_owner_changes=True)
585
self.mandos_serv = dbus.Interface(
586
mandos_dbus_objc, dbus_interface=server_interface)
581
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
582
dbus_interface
583
= server_interface)
587
584
try:
588
585
mandos_clients = (self.mandos_serv
589
586
.GetAllClientsWithProperties())
590
if not mandos_clients:
591
log.warning("Note: Server has no clients.")
592
587
except dbus.exceptions.DBusException:
593
log.warning("Note: No Mandos server running.")
594
588
mandos_clients = dbus.Dictionary()
595
589
596
590
(self.mandos_serv
597
.connect_to_signal("InterfacesRemoved",
591
.connect_to_signal("ClientRemoved",
598
592
self.find_and_remove_client,
599
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
593
dbus_interface=server_interface,
600
594
byte_arrays=True))
601
595
(self.mandos_serv
602
.connect_to_signal("InterfacesAdded",
596
.connect_to_signal("ClientAdded",
603
597
self.add_new_client,
604
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
598
dbus_interface=server_interface,
605
599
byte_arrays=True))
606
600
(self.mandos_serv
607
601
.connect_to_signal("ClientNotFound",
608
602
self.client_not_found,
609
603
dbus_interface=server_interface,
610
604
byte_arrays=True))
611
for path, client in mandos_clients.items():
605
for path, client in mandos_clients.iteritems():
612
606
client_proxy_object = self.bus.get_object(self.busname,
613
607
path)
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),
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),
620
619
path=path)
621
620
622
621
self.refresh()
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)))
622
self._input_callback_tag = (gobject.io_add_watch
623
(sys.stdin.fileno(),
624
gobject.IO_IN,
625
self.process_input))
628
626
self.main_loop.run()
629
627
# Main loop has finished, we should close everything now
630
GLib.source_remove(self._input_callback_tag)
631
with warnings.catch_warnings():
632
warnings.simplefilter("ignore", BytesWarning)
633
self.screen.stop()
634
628
gobject.source_remove(self._input_callback_tag)
629
self.screen.stop()
630
635
631
def stop(self):
636
632
self.main_loop.quit()
637
log.removeHandler(self.loghandler)
638
log.propagate = self.orig_log_propagate
639
633
640
634
def process_input(self, source, condition):
641
635
keys = self.screen.get_input()
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
}
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
}
652
646
for key in keys:
653
647
try:
654
648
key = translations[key]
655
649
except KeyError: # :-)
656
650
pass
657
651
658
652
if key == "q" or key == "Q":
659
653
self.stop()
660
654
break
661
655
elif key == "window resize":
662
656
self.size = self.screen.get_cols_rows()
663
657
self.refresh()
664
elif key == "ctrl l":
665
self.screen.clear()
658
elif key == "\f": # Ctrl-L
666
659
self.refresh()
667
660
elif key == "l" or key == "D":
668
661
self.toggle_log_display()
674
667
if not self.log_visible:
675
668
self.log_visible = True
676
669
self.rebuild()
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
))))
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"))))
696
688
self.refresh()
697
689
elif key == "tab":
698
690
if self.topwidget.get_focus() is self.logbox:
700
692
else:
701
693
self.topwidget.set_focus(self.logbox)
702
694
self.refresh()
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
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
728
713
elif self.topwidget.selectable():
729
714
self.topwidget.keypress(self.size, key)
730
715
self.refresh()
731
716
return True
732
717
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
747
718
ui = UserInterface()
748
719
try:
749
720
ui.run()
750
721
except KeyboardInterrupt:
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()
722
ui.screen.stop()
723
except Exception, e:
724
ui.log_message(unicode(e))
725
ui.screen.stop()
758
726
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0