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 614
- compare with another revision
- download diff
- download tarball
- view history from revision 614
- Committer: Teddy Hogeborn
- Date: 2012-10-24 19:34:13 UTC
- Revision ID: teddy@recompile.se-20121024193413-yiorm0x5lj48fu7i
* mandos: Comment changes.
* mandos-keygen (--password): Fix bashism. Thanks to Raphael Geissert
<atomo64@gmail.com> for the bug report.
* mandos-keygen (--password): Fix bashism. Thanks to Raphael Geissert
<atomo64@gmail.com> for the bug report.
- 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.9"
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.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)
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
"""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."""
496
498
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,
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),
501
503
coming_from="above")
502
504
self.refresh()
503
505
504
506
def toggle_log_display(self):
505
507
"""Toggle visibility of the log buffer."""
506
508
self.log_visible = not self.log_visible
507
509
self.rebuild()
508
log.debug("Log visibility changed to: %s", self.log_visible)
509
510
#self.log_message("Log visibility changed to: "
511
# + unicode(self.log_visible))
512
510
513
def change_log_display(self):
511
514
"""Change type of log display.
512
515
Currently, this toggles wrapping of text lines."""
516
519
self.log_wrap = "clip"
517
520
for textwidget in self.log:
518
521
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):
522
#self.log_message("Wrap mode: " + self.log_wrap)
523
524
def find_and_remove_client(self, path, name):
522
525
"""Find a client by its object path and remove it.
523
524
This is connected to the InterfacesRemoved signal from the
526
527
This is connected to the ClientRemoved signal from the
525
528
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
log.warning("Unknown client %s removed", path)
533
self.log_message("Unknown client {0!r} ({1!r}) removed"
534
.format(name, path))
534
535
return
535
536
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
537
538
def add_new_client(self, path):
546
539
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])),
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),
553
550
path=path)
554
551
555
552
def add_client(self, client, path=None):
556
553
self.clients.append(client)
557
554
if path is None:
558
555
path = client.proxy.object_path
559
556
self.clients_dict[path] = client
560
self.clients.sort(key=lambda c: c.properties["Name"])
557
self.clients.sort(None, lambda c: c.properties["Name"])
561
558
self.refresh()
562
559
563
560
def remove_client(self, client, path=None):
564
561
self.clients.remove(client)
565
562
if path is None:
566
563
path = client.proxy.object_path
567
564
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()
568
570
self.refresh()
569
571
570
572
def refresh(self):
571
573
"""Redraw the screen"""
572
574
canvas = self.topwidget.render(self.size, focus=True)
573
575
self.screen.draw_screen(self.size, canvas)
574
576
575
577
def run(self):
576
578
"""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
579
self.bus = dbus.SystemBus()
583
580
mandos_dbus_objc = self.bus.get_object(
584
581
self.busname, "/", follow_name_owner_changes=True)
585
self.mandos_serv = dbus.Interface(
586
mandos_dbus_objc, dbus_interface=server_interface)
582
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
583
dbus_interface
584
= server_interface)
587
585
try:
588
586
mandos_clients = (self.mandos_serv
589
587
.GetAllClientsWithProperties())
590
588
if not mandos_clients:
591
log.warning("Note: Server has no clients.")
589
self.log_message_raw(("bold", "Note: Server has no clients."))
592
590
except dbus.exceptions.DBusException:
593
log.warning("Note: No Mandos server running.")
591
self.log_message_raw(("bold", "Note: No Mandos servers running."))
594
592
mandos_clients = dbus.Dictionary()
595
593
596
594
(self.mandos_serv
597
.connect_to_signal("InterfacesRemoved",
595
.connect_to_signal("ClientRemoved",
598
596
self.find_and_remove_client,
599
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
597
dbus_interface=server_interface,
600
598
byte_arrays=True))
601
599
(self.mandos_serv
602
.connect_to_signal("InterfacesAdded",
600
.connect_to_signal("ClientAdded",
603
601
self.add_new_client,
604
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
602
dbus_interface=server_interface,
605
603
byte_arrays=True))
606
604
(self.mandos_serv
607
605
.connect_to_signal("ClientNotFound",
608
606
self.client_not_found,
609
607
dbus_interface=server_interface,
610
608
byte_arrays=True))
611
for path, client in mandos_clients.items():
609
for path, client in mandos_clients.iteritems():
612
610
client_proxy_object = self.bus.get_object(self.busname,
613
611
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),
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),
620
623
path=path)
621
624
622
625
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)))
626
self._input_callback_tag = (gobject.io_add_watch
627
(sys.stdin.fileno(),
628
gobject.IO_IN,
629
self.process_input))
628
630
self.main_loop.run()
629
631
# 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
632
gobject.source_remove(self._input_callback_tag)
633
self.screen.stop()
634
635
635
def stop(self):
636
636
self.main_loop.quit()
637
log.removeHandler(self.loghandler)
638
log.propagate = self.orig_log_propagate
639
637
640
638
def process_input(self, source, condition):
641
639
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
}
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
}
652
650
for key in keys:
653
651
try:
654
652
key = translations[key]
655
653
except KeyError: # :-)
656
654
pass
657
655
658
656
if key == "q" or key == "Q":
659
657
self.stop()
660
658
break
661
659
elif key == "window resize":
662
660
self.size = self.screen.get_cols_rows()
663
661
self.refresh()
664
elif key == "ctrl l":
665
self.screen.clear()
662
elif key == "\f": # Ctrl-L
666
663
self.refresh()
667
664
elif key == "l" or key == "D":
668
665
self.toggle_log_display()
674
671
if not self.log_visible:
675
672
self.log_visible = True
676
673
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
))))
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"))))
696
692
self.refresh()
697
693
elif key == "tab":
698
694
if self.topwidget.get_focus() is self.logbox:
700
696
else:
701
697
self.topwidget.set_focus(self.logbox)
702
698
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
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
728
717
elif self.topwidget.selectable():
729
718
self.topwidget.keypress(self.size, key)
730
719
self.refresh()
731
720
return True
732
721
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
722
ui = UserInterface()
748
723
try:
749
724
ui.run()
750
725
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()
726
ui.screen.stop()
727
except Exception, e:
728
ui.log_message(unicode(e))
729
ui.screen.stop()
758
730
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0