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.1.150
- compare with another revision
- download diff
- download tarball
- view history from revision 24.1.150
- Committer: Björn Påhlsson
- Date: 2010-08-22 18:35:37 UTC
- mto: (24.1.154 mandos) (237.4.3 mandos-release)
- mto: This revision was merged to the branch mainline in revision 421.
- Revision ID: belorn@fukt.bsnet.se-20100822183537-6trr1puyjvk14ejg
* mandos: Added ClientDBus.approve_pending property. Exposed
approved_by_default, approved_delay, approved_duration as
D-Bus properties.
approved_by_default, approved_delay, approved_duration as
D-Bus properties.
- 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, '')
55
56
import logging
57
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
24
locale.setlocale(locale.LC_ALL, u'')
58
25
59
26
# Some useful constants
60
domain = 'se.recompile'
27
domain = 'se.bsnet.fukt'
61
28
server_interface = domain + '.Mandos'
62
29
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
30
version = "1.0.14"
31
32
# Always run in monochrome mode
33
urwid.curses_display.curses.has_colors = lambda : False
34
35
# Urwid doesn't support blinking, but we want it. Since we have no
36
# use for underline on its own, we make underline also always blink.
37
urwid.curses_display.curses.A_UNDERLINE |= (
38
urwid.curses_display.curses.A_BLINK)
80
39
81
40
class MandosClientPropertyCache(object):
82
41
"""This wraps a Mandos Client D-Bus proxy object, caches the
83
42
properties and calls a hook function when any of them are
84
43
changed.
85
44
"""
86
def __init__(self, proxy_object=None, properties=None, **kwargs):
45
def __init__(self, proxy_object=None, *args, **kwargs):
87
46
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)
47
48
self.properties = dict()
49
self.proxy.connect_to_signal(u"PropertyChanged",
50
self.property_changed,
51
client_interface,
52
byte_arrays=True)
53
54
self.properties.update(
55
self.proxy.GetAll(client_interface,
56
dbus_interface = dbus.PROPERTIES_IFACE))
57
super(MandosClientPropertyCache, self).__init__(
58
proxy_object=proxy_object, *args, **kwargs)
102
59
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.
60
def property_changed(self, property=None, value=None):
61
"""This is called whenever we get a PropertyChanged signal
62
It updates the changed property in the "properties" dict.
106
63
"""
107
64
# Update properties dict with new value
108
self.properties.update(properties)
109
110
def delete(self):
111
self.property_changed_match.remove()
65
self.properties[property] = value
112
66
113
67
114
68
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
116
70
"""
117
71
118
72
def __init__(self, server_proxy_object=None, update_hook=None,
119
delete_hook=None, logger=None, **kwargs):
73
delete_hook=None, logger=None, *args, **kwargs):
120
74
# Called on update
121
75
self.update_hook = update_hook
122
76
# Called on delete
126
80
# Logger
127
81
self.logger = logger
128
82
129
self._update_timer_callback_tag = None
130
131
83
# The widget shown normally
132
self._text_widget = urwid.Text("")
84
self._text_widget = urwid.Text(u"")
133
85
# The widget shown when we have focus
134
self._focus_text_widget = urwid.Text("")
135
super(MandosClientWidget, self).__init__(**kwargs)
86
self._focus_text_widget = urwid.Text(u"")
87
super(MandosClientWidget, self).__init__(
88
update_hook=update_hook, delete_hook=delete_hook,
89
*args, **kwargs)
136
90
self.update()
137
91
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
92
self.proxy.connect_to_signal(u"CheckerCompleted",
93
self.checker_completed,
94
client_interface,
95
byte_arrays=True)
96
self.proxy.connect_to_signal(u"CheckerStarted",
97
self.checker_started,
98
client_interface,
99
byte_arrays=True)
100
self.proxy.connect_to_signal(u"GotSecret",
101
self.got_secret,
102
client_interface,
103
byte_arrays=True)
104
self.proxy.connect_to_signal(u"Rejected",
105
self.rejected,
106
client_interface,
107
byte_arrays=True)
175
108
176
109
def checker_completed(self, exitstatus, condition, command):
177
110
if exitstatus == 0:
178
self.logger('Checker for client {} (command "{}")'
179
' succeeded'.format(self.properties["Name"],
180
command), level=0)
181
self.update()
111
self.logger(u'Checker for client %s (command "%s")'
112
u' was successful'
113
% (self.properties[u"name"], command))
182
114
return
183
# Checker failed
184
115
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()
116
self.logger(u'Checker for client %s (command "%s")'
117
u' failed with exit code %s'
118
% (self.properties[u"name"], command,
119
os.WEXITSTATUS(condition)))
120
return
121
if os.WIFSIGNALED(condition):
122
self.logger(u'Checker for client %s (command "%s")'
123
u' was killed by signal %s'
124
% (self.properties[u"name"], command,
125
os.WTERMSIG(condition)))
126
return
127
if os.WCOREDUMP(condition):
128
self.logger(u'Checker for client %s (command "%s")'
129
u' dumped core'
130
% (self.properties[u"name"], command))
131
self.logger(u'Checker for client %s completed mysteriously')
203
132
204
133
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)
134
self.logger(u'Client %s started checker "%s"'
135
% (self.properties[u"name"], unicode(command)))
209
136
210
137
def got_secret(self):
211
self.logger('Client {} received its secret'
212
.format(self.properties["Name"]))
213
214
def need_approval(self, timeout, default):
215
if not default:
216
message = 'Client {} needs approval within {} seconds'
217
else:
218
message = 'Client {} will get its secret in {} seconds'
219
self.logger(message.format(self.properties["Name"],
220
timeout/1000))
221
222
def rejected(self, reason):
223
self.logger('Client {} was rejected; reason: {}'
224
.format(self.properties["Name"], reason))
138
self.logger(u'Client %s received its secret'
139
% self.properties[u"name"])
140
141
def rejected(self):
142
self.logger(u'Client %s was rejected'
143
% self.properties[u"name"])
225
144
226
145
def selectable(self):
227
146
"""Make this a "selectable" widget.
228
147
This overrides the method from urwid.FlowWidget."""
229
148
return True
230
149
231
def rows(self, maxcolrow, focus=False):
150
def rows(self, (maxcol,), focus=False):
232
151
"""How many rows this widget will occupy might depend on
233
152
whether we have focus or not.
234
153
This overrides the method from urwid.FlowWidget"""
235
return self.current_widget(focus).rows(maxcolrow, focus=focus)
154
return self.current_widget(focus).rows((maxcol,), focus=focus)
236
155
237
156
def current_widget(self, focus=False):
238
157
if focus or self.opened:
242
161
def update(self):
243
162
"Called when what is visible on the screen should be updated."
244
163
# 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",
164
with_standout = { u"normal": u"standout",
165
u"bold": u"bold-standout",
166
u"underline-blink":
167
u"underline-blink-standout",
168
u"bold-underline-blink":
169
u"bold-underline-blink-standout",
251
170
}
252
171
253
172
# 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
173
self._text = (u'%(name)s: %(enabled)s'
174
% { u"name": self.properties[u"name"],
175
u"enabled":
176
(u"enabled"
177
if self.properties[u"enabled"]
178
else u"DISABLED")})
297
179
if not urwid.supports_unicode():
298
180
self._text = self._text.encode("ascii", "replace")
299
textlist = [("normal", self._text)]
181
textlist = [(u"normal", self._text)]
300
182
self._text_widget.set_text(textlist)
301
183
self._focus_text_widget.set_text([(with_standout[text[0]],
302
184
text[1])
310
192
if self.update_hook is not None:
311
193
self.update_hook()
312
194
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 = ()
195
def delete(self):
326
196
if self.delete_hook is not None:
327
197
self.delete_hook(self)
328
return super(MandosClientWidget, self).delete(**kwargs)
329
198
330
def render(self, maxcolrow, focus=False):
199
def render(self, (maxcol,), focus=False):
331
200
"""Render differently if we have focus.
332
201
This overrides the method from urwid.FlowWidget"""
333
return self.current_widget(focus).render(maxcolrow,
202
return self.current_widget(focus).render((maxcol,),
334
203
focus=focus)
335
204
336
def keypress(self, maxcolrow, key):
205
def keypress(self, (maxcol,), key):
337
206
"""Handle keys.
338
207
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":
208
if key == u"e" or key == u"+":
209
self.proxy.Enable()
210
elif key == u"d" or key == u"-":
211
self.proxy.Disable()
212
elif key == u"r" or key == u"_" or key == u"ctrl k":
354
213
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)
214
.object_path)
215
elif key == u"s":
216
self.proxy.StartChecker()
217
elif key == u"S":
218
self.proxy.StopChecker()
219
elif key == u"C":
220
self.proxy.CheckedOK()
366
221
# xxx
367
# elif key == "p" or key == "=":
222
# elif key == u"p" or key == "=":
368
223
# self.proxy.pause()
369
# elif key == "u" or key == ":":
224
# elif key == u"u" or key == ":":
370
225
# self.proxy.unpause()
371
# elif key == "RET":
226
# elif key == u"RET":
372
227
# self.open()
373
228
else:
374
229
return key
375
230
376
def properties_changed(self, interface, properties, invalidated):
377
"""Call self.update() if any properties changed.
231
def property_changed(self, property=None, value=None,
232
*args, **kwargs):
233
"""Call self.update() if old value is not new value.
378
234
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):
235
property_name = unicode(property)
236
old_value = self.properties.get(property_name)
237
super(MandosClientWidget, self).property_changed(
238
property=property, value=value, *args, **kwargs)
239
if self.properties.get(property_name) != old_value:
385
240
self.update()
386
241
387
242
390
245
"down" key presses, thus not allowing any containing widgets to
391
246
use them as an excuse to shift focus away from this widget.
392
247
"""
393
def keypress(self, *args, **kwargs):
394
ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
395
if ret in ("up", "down"):
248
def keypress(self, (maxcol, maxrow), key):
249
ret = super(ConstrainedListBox, self).keypress((maxcol, maxrow), key)
250
if ret in (u"up", u"down"):
396
251
return
397
252
return ret
398
253
401
256
"""This is the entire user interface - the whole screen
402
257
with boxes, lists of client widgets, etc.
403
258
"""
404
def __init__(self, max_log_length=1000, log_level=1):
259
def __init__(self, max_log_length=1000):
405
260
DBusGMainLoop(set_as_default=True)
406
261
407
262
self.screen = urwid.curses_display.Screen()
408
263
409
264
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"),
265
(u"normal",
266
u"default", u"default", None),
267
(u"bold",
268
u"default", u"default", u"bold"),
269
(u"underline-blink",
270
u"default", u"default", u"underline"),
271
(u"standout",
272
u"default", u"default", u"standout"),
273
(u"bold-underline-blink",
274
u"default", u"default", (u"bold", u"underline")),
275
(u"bold-standout",
276
u"default", u"default", (u"bold", u"standout")),
277
(u"underline-blink-standout",
278
u"default", u"default", (u"underline", u"standout")),
279
(u"bold-underline-blink-standout",
280
u"default", u"default", (u"bold", u"underline",
281
u"standout")),
428
282
))
429
283
430
284
if urwid.supports_unicode():
431
self.divider = "─" # \u2500
432
#self.divider = "━" # \u2501
285
self.divider = u"─" # \u2500
286
#self.divider = u"━" # \u2501
433
287
else:
434
#self.divider = "-" # \u002d
435
self.divider = "_" # \u005f
288
#self.divider = u"-" # \u002d
289
self.divider = u"_" # \u005f
436
290
437
291
self.screen.start()
438
292
445
299
self.log = []
446
300
self.max_log_length = max_log_length
447
301
448
self.log_level = log_level
449
450
302
# We keep a reference to the log widget so we can remove it
451
303
# from the ListWalker without it getting destroyed
452
304
self.logbox = ConstrainedListBox(self.log)
454
306
# This keeps track of whether self.uilist currently has
455
307
# self.logbox in it or not
456
308
self.log_visible = True
457
self.log_wrap = "any"
309
self.log_wrap = u"any"
458
310
459
311
self.rebuild()
460
self.log_message_raw(("bold",
461
"Mandos Monitor version " + version))
462
self.log_message_raw(("bold",
463
"q: Quit ?: Help"))
312
self.log_message_raw((u"bold",
313
u"Mandos Monitor version " + version))
314
self.log_message_raw((u"bold",
315
u"q: Quit ?: Help"))
464
316
465
317
self.busname = domain + '.Mandos'
466
318
self.main_loop = gobject.MainLoop()
319
self.bus = dbus.SystemBus()
320
mandos_dbus_objc = self.bus.get_object(
321
self.busname, u"/", follow_name_owner_changes=True)
322
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
323
dbus_interface
324
= server_interface)
325
try:
326
mandos_clients = (self.mandos_serv
327
.GetAllClientsWithProperties())
328
except dbus.exceptions.DBusException:
329
mandos_clients = dbus.Dictionary()
330
331
(self.mandos_serv
332
.connect_to_signal(u"ClientRemoved",
333
self.find_and_remove_client,
334
dbus_interface=server_interface,
335
byte_arrays=True))
336
(self.mandos_serv
337
.connect_to_signal(u"ClientAdded",
338
self.add_new_client,
339
dbus_interface=server_interface,
340
byte_arrays=True))
341
(self.mandos_serv
342
.connect_to_signal(u"ClientNotFound",
343
self.client_not_found,
344
dbus_interface=server_interface,
345
byte_arrays=True))
346
for path, client in mandos_clients.iteritems():
347
client_proxy_object = self.bus.get_object(self.busname,
348
path)
349
self.add_client(MandosClientWidget(server_proxy_object
350
=self.mandos_serv,
351
proxy_object
352
=client_proxy_object,
353
properties=client,
354
update_hook
355
=self.refresh,
356
delete_hook
357
=self.remove_client,
358
logger
359
=self.log_message),
360
path=path)
467
361
468
362
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))
363
self.log_message((u"Client with address %s and fingerprint %s"
364
u" could not be found" % (address,
365
fingerprint)))
472
366
473
367
def rebuild(self):
474
368
"""This rebuilds the User Interface.
475
369
Call this when the widget layout needs to change"""
476
370
self.uilist = []
477
371
#self.uilist.append(urwid.ListBox(self.clients))
478
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
479
clients),
372
self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),
480
373
#header=urwid.Divider(),
481
374
header=None,
482
footer=
483
urwid.Divider(div_char=
484
self.divider)))
375
footer=urwid.Divider(div_char=self.divider)))
485
376
if self.log_visible:
486
377
self.uilist.append(self.logbox)
378
pass
487
379
self.topwidget = urwid.Pile(self.uilist)
488
380
489
def log_message(self, message, level=1):
490
"""Log message formatted with timestamp"""
491
if level < self.log_level:
492
return
381
def log_message(self, message):
493
382
timestamp = datetime.datetime.now().isoformat()
494
self.log_message_raw("{}: {}".format(timestamp, message),
495
level=level)
383
self.log_message_raw(timestamp + u": " + message)
496
384
497
def log_message_raw(self, markup, level=1):
385
def log_message_raw(self, markup):
498
386
"""Add a log message to the log buffer."""
499
if level < self.log_level:
500
return
501
387
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
502
388
if (self.max_log_length
503
389
and len(self.log) > self.max_log_length):
504
390
del self.log[0:len(self.log)-self.max_log_length-1]
505
391
self.logbox.set_focus(len(self.logbox.body.contents),
506
coming_from="above")
392
coming_from=u"above")
507
393
self.refresh()
508
394
509
395
def toggle_log_display(self):
510
396
"""Toggle visibility of the log buffer."""
511
397
self.log_visible = not self.log_visible
512
398
self.rebuild()
513
self.log_message("Log visibility changed to: {}"
514
.format(self.log_visible), level=0)
399
self.log_message(u"Log visibility changed to: "
400
+ unicode(self.log_visible))
515
401
516
402
def change_log_display(self):
517
403
"""Change type of log display.
518
404
Currently, this toggles wrapping of text lines."""
519
if self.log_wrap == "clip":
520
self.log_wrap = "any"
405
if self.log_wrap == u"clip":
406
self.log_wrap = u"any"
521
407
else:
522
self.log_wrap = "clip"
408
self.log_wrap = u"clip"
523
409
for textwidget in self.log:
524
410
textwidget.set_wrap_mode(self.log_wrap)
525
self.log_message("Wrap mode: {}".format(self.log_wrap),
526
level=0)
411
self.log_message(u"Wrap mode: " + self.log_wrap)
527
412
528
413
def find_and_remove_client(self, path, name):
529
"""Find a client by its object path and remove it.
414
"""Find an client from its object path and remove it.
530
415
531
416
This is connected to the ClientRemoved signal from the
532
417
Mandos server object."""
534
419
client = self.clients_dict[path]
535
420
except KeyError:
536
421
# not found?
537
self.log_message("Unknown client {!r} ({!r}) removed"
538
.format(name, path))
539
422
return
540
client.delete()
423
self.remove_client(client, path)
541
424
542
425
def add_new_client(self, path):
543
426
client_proxy_object = self.bus.get_object(self.busname, path)
558
441
if path is None:
559
442
path = client.proxy.object_path
560
443
self.clients_dict[path] = client
561
self.clients.sort(key=lambda c: c.properties["Name"])
444
self.clients.sort(None, lambda c: c.properties[u"name"])
562
445
self.refresh()
563
446
564
447
def remove_client(self, client, path=None):
566
449
if path is None:
567
450
path = client.proxy.object_path
568
451
del self.clients_dict[path]
452
if not self.clients_dict:
453
# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
454
# is completely emptied, we need to recreate it.
455
self.clients = urwid.SimpleListWalker([])
456
self.rebuild()
569
457
self.refresh()
570
458
571
459
def refresh(self):
575
463
576
464
def run(self):
577
465
"""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
466
self.refresh()
625
467
self._input_callback_tag = (gobject.io_add_watch
626
468
(sys.stdin.fileno(),
636
478
637
479
def process_input(self, source, condition):
638
480
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
481
translations = { u"ctrl n": u"down", # Emacs
482
u"ctrl p": u"up", # Emacs
483
u"ctrl v": u"page down", # Emacs
484
u"meta v": u"page up", # Emacs
485
u" ": u"page down", # less
486
u"f": u"page down", # less
487
u"b": u"page up", # less
488
u"j": u"down", # vi
489
u"k": u"up", # vi
648
490
}
649
491
for key in keys:
650
492
try:
652
494
except KeyError: # :-)
653
495
pass
654
496
655
if key == "q" or key == "Q":
497
if key == u"q" or key == u"Q":
656
498
self.stop()
657
499
break
658
elif key == "window resize":
500
elif key == u"window resize":
659
501
self.size = self.screen.get_cols_rows()
660
502
self.refresh()
661
elif key == "ctrl l":
662
self.screen.clear()
503
elif key == u"\f": # Ctrl-L
663
504
self.refresh()
664
elif key == "l" or key == "D":
505
elif key == u"l" or key == u"D":
665
506
self.toggle_log_display()
666
507
self.refresh()
667
elif key == "w" or key == "i":
508
elif key == u"w" or key == u"i":
668
509
self.change_log_display()
669
510
self.refresh()
670
elif key == "?" or key == "f1" or key == "esc":
511
elif key == u"?" or key == u"f1" or key == u"esc":
671
512
if not self.log_visible:
672
513
self.log_visible = True
673
514
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"))))
515
self.log_message_raw((u"bold",
516
u" ".
517
join((u"q: Quit",
518
u"?: Help",
519
u"l: Log window toggle",
520
u"TAB: Switch window",
521
u"w: Wrap (log)"))))
522
self.log_message_raw((u"bold",
523
u" "
524
.join((u"Clients:",
525
u"e: Enable",
526
u"d: Disable",
527
u"r: Remove",
528
u"s: Start new checker",
529
u"S: Stop checker",
530
u"C: Checker OK"))))
694
531
self.refresh()
695
elif key == "tab":
532
elif key == u"tab":
696
533
if self.topwidget.get_focus() is self.logbox:
697
534
self.topwidget.set_focus(0)
698
535
else:
699
536
self.topwidget.set_focus(self.logbox)
700
537
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 == ">"):
538
#elif (key == u"end" or key == u"meta >" or key == u"G"
539
# or key == u">"):
710
540
# pass # xxx end-of-buffer
711
#elif (key == "home" or key == "meta <" or key == "g"
712
# or key == "<"):
541
#elif (key == u"home" or key == u"meta <" or key == u"g"
542
# or key == u"<"):
713
543
# pass # xxx beginning-of-buffer
714
#elif key == "ctrl e" or key == "$":
544
#elif key == u"ctrl e" or key == u"$":
715
545
# pass # xxx move-end-of-line
716
#elif key == "ctrl a" or key == "^":
546
#elif key == u"ctrl a" or key == u"^":
717
547
# pass # xxx move-beginning-of-line
718
#elif key == "ctrl b" or key == "meta (" or key == "h":
548
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
719
549
# pass # xxx left
720
#elif key == "ctrl f" or key == "meta )" or key == "l":
550
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
721
551
# pass # xxx right
722
#elif key == "a":
552
#elif key == u"a":
723
553
# pass # scroll up log
724
#elif key == "z":
554
#elif key == u"z":
725
555
# pass # scroll down log
726
556
elif self.topwidget.selectable():
727
557
self.topwidget.keypress(self.size, key)
731
561
ui = UserInterface()
732
562
try:
733
563
ui.run()
734
except KeyboardInterrupt:
735
ui.screen.stop()
736
except Exception as e:
737
ui.log_message(str(e))
564
except Exception, e:
565
ui.log_message(unicode(e))
738
566
ui.screen.stop()
739
567
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0