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