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