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