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