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