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