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