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