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.122
- compare with another revision
- download diff
- download tarball
- view history from revision 237.7.122
- Committer: Teddy Hogeborn
- Date: 2012-05-05 10:52:11 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-20120505105211-58z3hyjfzep3z2q9
* mandos: White space and other misc. format fixes only.
- 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
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
31
import signal
36
32
37
33
import datetime
38
34
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.5"
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
489
self.main_loop = gobject.MainLoop()
490
470
491
def client_not_found(self, fingerprint, address):
471
self.log_message("Client with address {} and fingerprint {}"
472
" could not be found"
492
self.log_message("Client with address {0} and fingerprint"
493
" {1} could not be found"
473
494
.format(address, fingerprint))
474
495
475
496
def rebuild(self):
476
497
"""This rebuilds the User Interface.
477
498
Call this when the widget layout needs to change"""
478
499
self.uilist = []
479
# self.uilist.append(urwid.ListBox(self.clients))
500
#self.uilist.append(urwid.ListBox(self.clients))
480
501
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
481
502
clients),
482
# header=urwid.Divider(),
503
#header=urwid.Divider(),
483
504
header=None,
484
footer=urwid.Divider(
485
div_char=self.divider)))
505
footer=
506
urwid.Divider(div_char=
507
self.divider)))
486
508
if self.log_visible:
487
509
self.uilist.append(self.logbox)
488
510
self.topwidget = urwid.Pile(self.uilist)
489
490
def log_message(self, message, level=1):
491
"""Log message formatted with timestamp"""
492
if level < self.log_level:
493
return
511
512
def log_message(self, message):
494
513
timestamp = datetime.datetime.now().isoformat()
495
self.log_message_raw("{}: {}".format(timestamp, message),
496
level=level)
497
498
def log_message_raw(self, markup, level=1):
514
self.log_message_raw(timestamp + ": " + message)
515
516
def log_message_raw(self, markup):
499
517
"""Add a log message to the log buffer."""
500
if level < self.log_level:
501
return
502
518
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
503
if self.max_log_length:
504
if len(self.log) > self.max_log_length:
505
del self.log[0:len(self.log)-self.max_log_length-1]
506
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),
507
523
coming_from="above")
508
524
self.refresh()
509
525
510
526
def toggle_log_display(self):
511
527
"""Toggle visibility of the log buffer."""
512
528
self.log_visible = not self.log_visible
513
529
self.rebuild()
514
self.log_message("Log visibility changed to: {}"
515
.format(self.log_visible), level=0)
516
530
#self.log_message("Log visibility changed to: "
531
# + unicode(self.log_visible))
532
517
533
def change_log_display(self):
518
534
"""Change type of log display.
519
535
Currently, this toggles wrapping of text lines."""
523
539
self.log_wrap = "clip"
524
540
for textwidget in self.log:
525
541
textwidget.set_wrap_mode(self.log_wrap)
526
self.log_message("Wrap mode: {}".format(self.log_wrap),
527
level=0)
528
529
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):
530
545
"""Find a client by its object path and remove it.
531
532
This is connected to the InterfacesRemoved signal from the
546
547
This is connected to the ClientRemoved signal from the
533
548
Mandos server object."""
534
if client_interface not in interfaces:
535
# Not a Mandos client object; ignore
536
return
537
549
try:
538
550
client = self.clients_dict[path]
539
551
except KeyError:
540
552
# not found?
541
self.log_message("Unknown client {!r} removed"
542
.format(path))
553
self.log_message("Unknown client {0!r} ({1!r}) removed"
554
.format(name, path))
543
555
return
544
556
client.delete()
545
546
def add_new_client(self, path, ifs_and_props):
547
"""Find a client by its object path and remove it.
548
549
This is connected to the InterfacesAdded signal from the
550
Mandos server object.
551
"""
552
if client_interface not in ifs_and_props:
553
# Not a Mandos client object; ignore
554
return
557
558
def add_new_client(self, path):
555
559
client_proxy_object = self.bus.get_object(self.busname, path)
556
self.add_client(MandosClientWidget(
557
server_proxy_object=self.mandos_serv,
558
proxy_object=client_proxy_object,
559
update_hook=self.refresh,
560
delete_hook=self.remove_client,
561
logger=self.log_message,
562
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),
563
570
path=path)
564
571
565
572
def add_client(self, client, path=None):
566
573
self.clients.append(client)
567
574
if path is None:
568
575
path = client.proxy.object_path
569
576
self.clients_dict[path] = client
570
self.clients.sort(key=lambda c: c.properties["Name"])
577
self.clients.sort(None, lambda c: c.properties["Name"])
571
578
self.refresh()
572
579
573
580
def remove_client(self, client, path=None):
574
581
self.clients.remove(client)
575
582
if path is None:
576
583
path = client.proxy.object_path
577
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()
578
590
self.refresh()
579
591
580
592
def refresh(self):
581
593
"""Redraw the screen"""
582
594
canvas = self.topwidget.render(self.size, focus=True)
583
595
self.screen.draw_screen(self.size, canvas)
584
596
585
597
def run(self):
586
598
"""Start the main loop and exit when it's done."""
587
599
self.bus = dbus.SystemBus()
588
600
mandos_dbus_objc = self.bus.get_object(
589
601
self.busname, "/", follow_name_owner_changes=True)
590
self.mandos_serv = dbus.Interface(
591
mandos_dbus_objc, dbus_interface=server_interface)
602
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
603
dbus_interface
604
= server_interface)
592
605
try:
593
606
mandos_clients = (self.mandos_serv
594
607
.GetAllClientsWithProperties())
595
if not mandos_clients:
596
self.log_message_raw(("bold",
597
"Note: Server has no clients."))
598
608
except dbus.exceptions.DBusException:
599
self.log_message_raw(("bold",
600
"Note: No Mandos server running."))
601
609
mandos_clients = dbus.Dictionary()
602
610
603
611
(self.mandos_serv
604
.connect_to_signal("InterfacesRemoved",
612
.connect_to_signal("ClientRemoved",
605
613
self.find_and_remove_client,
606
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
614
dbus_interface=server_interface,
607
615
byte_arrays=True))
608
616
(self.mandos_serv
609
.connect_to_signal("InterfacesAdded",
617
.connect_to_signal("ClientAdded",
610
618
self.add_new_client,
611
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
619
dbus_interface=server_interface,
612
620
byte_arrays=True))
613
621
(self.mandos_serv
614
622
.connect_to_signal("ClientNotFound",
615
623
self.client_not_found,
616
624
dbus_interface=server_interface,
617
625
byte_arrays=True))
618
for path, client in mandos_clients.items():
626
for path, client in mandos_clients.iteritems():
619
627
client_proxy_object = self.bus.get_object(self.busname,
620
628
path)
621
self.add_client(MandosClientWidget(
622
server_proxy_object=self.mandos_serv,
623
proxy_object=client_proxy_object,
624
properties=client,
625
update_hook=self.refresh,
626
delete_hook=self.remove_client,
627
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),
628
640
path=path)
629
641
630
642
self.refresh()
631
self._input_callback_tag = (GLib.io_add_watch
643
self._input_callback_tag = (gobject.io_add_watch
632
644
(sys.stdin.fileno(),
633
GLib.IO_IN,
645
gobject.IO_IN,
634
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)
649
gobject.source_remove(self._input_callback_tag)
638
650
self.screen.stop()
639
651
640
652
def stop(self):
641
653
self.main_loop.quit()
642
654
643
655
def process_input(self, source, condition):
644
656
keys = self.screen.get_input()
645
translations = {"ctrl n": "down", # Emacs
646
"ctrl p": "up", # Emacs
647
"ctrl v": "page down", # Emacs
648
"meta v": "page up", # Emacs
649
" ": "page down", # less
650
"f": "page down", # less
651
"b": "page up", # less
652
"j": "down", # vi
653
"k": "up", # vi
654
}
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
}
655
667
for key in keys:
656
668
try:
657
669
key = translations[key]
658
670
except KeyError: # :-)
659
671
pass
660
672
661
673
if key == "q" or key == "Q":
662
674
self.stop()
663
675
break
664
676
elif key == "window resize":
665
677
self.size = self.screen.get_cols_rows()
666
678
self.refresh()
667
elif key == "ctrl l":
668
self.screen.clear()
679
elif key == "\f": # Ctrl-L
669
680
self.refresh()
670
681
elif key == "l" or key == "D":
671
682
self.toggle_log_display()
683
694
"?: Help",
684
695
"l: Log window toggle",
685
696
"TAB: Switch window",
686
"w: Wrap (log lines)",
687
"v: Toggle verbose log",
688
))))
697
"w: Wrap (log)"))))
689
698
self.log_message_raw(("bold",
690
699
" "
691
700
.join(("Clients:",
704
713
else:
705
714
self.topwidget.set_focus(self.logbox)
706
715
self.refresh()
707
elif key == "v":
708
if self.log_level == 0:
709
self.log_level = 1
710
self.log_message("Verbose mode: Off")
711
else:
712
self.log_level = 0
713
self.log_message("Verbose mode: On")
714
# elif (key == "end" or key == "meta >" or key == "G"
715
# or key == ">"):
716
# pass # xxx end-of-buffer
717
# elif (key == "home" or key == "meta <" or key == "g"
718
# or key == "<"):
719
# pass # xxx beginning-of-buffer
720
# elif key == "ctrl e" or key == "$":
721
# pass # xxx move-end-of-line
722
# elif key == "ctrl a" or key == "^":
723
# pass # xxx move-beginning-of-line
724
# elif key == "ctrl b" or key == "meta (" or key == "h":
725
# pass # xxx left
726
# elif key == "ctrl f" or key == "meta )" or key == "l":
727
# pass # xxx right
728
# elif key == "a":
729
# pass # scroll up log
730
# elif key == "z":
731
# 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
732
734
elif self.topwidget.selectable():
733
735
self.topwidget.keypress(self.size, key)
734
736
self.refresh()
735
737
return True
736
738
737
738
739
ui = UserInterface()
739
740
try:
740
741
ui.run()
741
742
except KeyboardInterrupt:
742
743
ui.screen.stop()
743
except Exception as e:
744
ui.log_message(str(e))
744
except Exception, e:
745
ui.log_message(unicode(e))
745
746
ui.screen.stop()
746
747
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0