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