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