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