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