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