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 308
- compare with another revision
- download diff
- download tarball
- view history from revision 308
- Committer: Teddy Hogeborn
- Date: 2014-01-21 21:04:25 UTC
- Revision ID: teddy@recompile.se-20140121210425-j1bgxxghrb751jej
Tags: version-1.6.3-1
* Makefile (version): Changed to "1.3.2".
* NEWS (Version 1.6.3): New entry.
* debian/changelog (1.6.3-1): - '' -
* NEWS (Version 1.6.3): New entry.
* debian/changelog (1.6.3-1): - '' -
- files added:
- DBUS-API
- debian/source
- 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-2013 Teddy Hogeborn
7
# Copyright © 2009-2013 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
13
40
import urwid
14
41
15
42
from dbus.mainloop.glib import DBusGMainLoop
16
import gobject
43
try:
44
import gobject
45
except ImportError:
46
from gi.repository import GObject as gobject
17
47
18
48
import dbus
19
49
20
import UserList
50
import locale
51
52
if sys.version_info[0] == 2:
53
str = unicode
54
55
locale.setlocale(locale.LC_ALL, '')
56
57
import logging
58
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
21
59
22
60
# Some useful constants
23
domain = 'se.bsnet.fukt'
61
domain = 'se.recompile'
24
62
server_interface = domain + '.Mandos'
25
63
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)
64
version = "1.6.3"
65
66
def isoformat_to_datetime(iso):
67
"Parse an ISO 8601 date string to a datetime.datetime()"
68
if not iso:
69
return None
70
d, t = iso.split("T", 1)
71
year, month, day = d.split("-", 2)
72
hour, minute, second = t.split(":", 2)
73
second, fraction = divmod(float(second), 1)
74
return datetime.datetime(int(year),
75
int(month),
76
int(day),
77
int(hour),
78
int(minute),
79
int(second), # Whole seconds
80
int(fraction*1000000)) # Microseconds
35
81
36
82
class MandosClientPropertyCache(object):
37
83
"""This wraps a Mandos Client D-Bus proxy object, caches the
38
84
properties and calls a hook function when any of them are
39
85
changed.
40
86
"""
41
def __init__(self, proxy_object=None, properties=None, *args,
42
**kwargs):
87
def __init__(self, proxy_object=None, properties=None, **kwargs):
43
88
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)
89
self.properties = dict() if properties is None else properties
90
self.property_changed_match = (
91
self.proxy.connect_to_signal("PropertyChanged",
92
self._property_changed,
93
client_interface,
94
byte_arrays=True))
95
96
if properties is None:
97
self.properties.update(
98
self.proxy.GetAll(client_interface,
99
dbus_interface
100
= dbus.PROPERTIES_IFACE))
101
102
super(MandosClientPropertyCache, self).__init__(**kwargs)
103
104
def _property_changed(self, property, value):
105
"""Helper which takes positional arguments"""
106
return self.property_changed(property=property, value=value)
61
107
62
108
def property_changed(self, property=None, value=None):
63
109
"""This is called whenever we get a PropertyChanged signal
65
111
"""
66
112
# Update properties dict with new value
67
113
self.properties[property] = value
114
115
def delete(self):
116
self.property_changed_match.remove()
68
117
69
118
70
119
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
72
121
"""
73
122
74
123
def __init__(self, server_proxy_object=None, update_hook=None,
75
delete_hook=None, logger=None, *args, **kwargs):
124
delete_hook=None, logger=None, **kwargs):
76
125
# Called on update
77
126
self.update_hook = update_hook
78
127
# Called on delete
82
131
# Logger
83
132
self.logger = logger
84
133
134
self._update_timer_callback_tag = None
135
85
136
# The widget shown normally
86
self._text_widget = urwid.Text(u"")
137
self._text_widget = urwid.Text("")
87
138
# 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)
139
self._focus_text_widget = urwid.Text("")
140
super(MandosClientWidget, self).__init__(**kwargs)
92
141
self.update()
93
142
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)
143
144
self.match_objects = (
145
self.proxy.connect_to_signal("CheckerCompleted",
146
self.checker_completed,
147
client_interface,
148
byte_arrays=True),
149
self.proxy.connect_to_signal("CheckerStarted",
150
self.checker_started,
151
client_interface,
152
byte_arrays=True),
153
self.proxy.connect_to_signal("GotSecret",
154
self.got_secret,
155
client_interface,
156
byte_arrays=True),
157
self.proxy.connect_to_signal("NeedApproval",
158
self.need_approval,
159
client_interface,
160
byte_arrays=True),
161
self.proxy.connect_to_signal("Rejected",
162
self.rejected,
163
client_interface,
164
byte_arrays=True))
165
#self.logger('Created client {0}'
166
# .format(self.properties["Name"]))
167
168
def using_timer(self, flag):
169
"""Call this method with True or False when timer should be
170
activated or deactivated.
171
"""
172
if flag and self._update_timer_callback_tag is None:
173
# Will update the shown timer value every second
174
self._update_timer_callback_tag = (gobject.timeout_add
175
(1000,
176
self.update_timer))
177
elif not (flag or self._update_timer_callback_tag is None):
178
gobject.source_remove(self._update_timer_callback_tag)
179
self._update_timer_callback_tag = None
110
180
111
181
def checker_completed(self, exitstatus, condition, command):
112
182
if exitstatus == 0:
113
self.logger(u'Checker for client %s (command "%s")'
114
u' was successful'
115
% (self.properties[u"name"], command))
183
self.update()
116
184
return
185
# Checker failed
117
186
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')
187
self.logger('Checker for client {0} (command "{1}")'
188
' failed with exit code {2}'
189
.format(self.properties["Name"], command,
190
os.WEXITSTATUS(condition)))
191
elif os.WIFSIGNALED(condition):
192
self.logger('Checker for client {0} (command "{1}") was'
193
' killed by signal {2}'
194
.format(self.properties["Name"], command,
195
os.WTERMSIG(condition)))
196
elif os.WCOREDUMP(condition):
197
self.logger('Checker for client {0} (command "{1}")'
198
' dumped core'
199
.format(self.properties["Name"], command))
200
else:
201
self.logger('Checker for client {0} completed'
202
' mysteriously'
203
.format(self.properties["Name"]))
204
self.update()
134
205
135
206
def checker_started(self, command):
136
self.logger(u'Client %s started checker "%s"'
137
% (self.properties[u"name"], unicode(command)))
207
"""Server signals that a checker started. This could be useful
208
to log in the future. """
209
#self.logger('Client {0} started checker "{1}"'
210
# .format(self.properties["Name"],
211
# str(command)))
212
pass
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 {0} received its secret'
216
.format(self.properties["Name"]))
217
218
def need_approval(self, timeout, default):
219
if not default:
220
message = 'Client {0} needs approval within {1} seconds'
221
else:
222
message = 'Client {0} will get its secret in {1} seconds'
223
self.logger(message.format(self.properties["Name"],
224
timeout/1000))
225
226
def rejected(self, reason):
227
self.logger('Client {0} was rejected; reason: {1}'
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 {0}. (d)eny?"
278
else:
279
message = "Denial in {0}. (a)pprove?"
280
message = message.format(str(timer).rsplit(".", 1)[0])
281
self.using_timer(True)
282
elif self.properties["LastCheckerStatus"] != 0:
283
# When checker has failed, show timer until client expires
284
expires = self.properties["Expires"]
285
if expires == "":
286
timer = datetime.timedelta(0)
287
else:
288
expires = (datetime.datetime.strptime
289
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
290
timer = max(expires - datetime.datetime.utcnow(),
291
datetime.timedelta())
292
message = ('A checker has failed! Time until client'
293
' gets disabled: {0}'
294
.format(str(timer).rsplit(".", 1)[0]))
295
self.using_timer(True)
296
else:
297
message = "enabled"
298
self.using_timer(False)
299
self._text = "{0}{1}".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
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
308
455
# This keeps track of whether self.uilist currently has
309
456
# self.logbox in it or not
310
457
self.log_visible = True
311
self.log_wrap = u"any"
458
self.log_wrap = "any"
312
459
313
460
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"))
461
self.log_message_raw(("bold",
462
"Mandos Monitor version " + version))
463
self.log_message_raw(("bold",
464
"q: Quit ?: Help"))
318
465
319
466
self.busname = domain + '.Mandos'
320
467
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
468
364
469
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)))
470
self.log_message("Client with address {0} and fingerprint"
471
" {1} could not be found"
472
.format(address, fingerprint))
368
473
369
474
def rebuild(self):
370
475
"""This rebuilds the User Interface.
371
476
Call this when the widget layout needs to change"""
372
477
self.uilist = []
373
478
#self.uilist.append(urwid.ListBox(self.clients))
374
self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),
479
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
480
clients),
375
481
#header=urwid.Divider(),
376
482
header=None,
377
footer=urwid.Divider(div_char=self.divider)))
483
footer=
484
urwid.Divider(div_char=
485
self.divider)))
378
486
if self.log_visible:
379
487
self.uilist.append(self.logbox)
380
pass
381
488
self.topwidget = urwid.Pile(self.uilist)
382
489
383
490
def log_message(self, message):
491
"""Log message formatted with timestamp"""
384
492
timestamp = datetime.datetime.now().isoformat()
385
self.log_message_raw(timestamp + u": " + message)
493
self.log_message_raw(timestamp + ": " + message)
386
494
387
495
def log_message_raw(self, markup):
388
496
"""Add a log message to the log buffer."""
391
499
and len(self.log) > self.max_log_length):
392
500
del self.log[0:len(self.log)-self.max_log_length-1]
393
501
self.logbox.set_focus(len(self.logbox.body.contents),
394
coming_from=u"above")
502
coming_from="above")
395
503
self.refresh()
396
504
397
505
def toggle_log_display(self):
398
506
"""Toggle visibility of the log buffer."""
399
507
self.log_visible = not self.log_visible
400
508
self.rebuild()
401
self.log_message(u"Log visibility changed to: "
402
+ unicode(self.log_visible))
509
#self.log_message("Log visibility changed to: "
510
# + str(self.log_visible))
403
511
404
512
def change_log_display(self):
405
513
"""Change type of log display.
406
514
Currently, this toggles wrapping of text lines."""
407
if self.log_wrap == u"clip":
408
self.log_wrap = u"any"
515
if self.log_wrap == "clip":
516
self.log_wrap = "any"
409
517
else:
410
self.log_wrap = u"clip"
518
self.log_wrap = "clip"
411
519
for textwidget in self.log:
412
520
textwidget.set_wrap_mode(self.log_wrap)
413
self.log_message(u"Wrap mode: " + self.log_wrap)
521
#self.log_message("Wrap mode: " + self.log_wrap)
414
522
415
523
def find_and_remove_client(self, path, name):
416
"""Find an client from its object path and remove it.
524
"""Find a client by its object path and remove it.
417
525
418
526
This is connected to the ClientRemoved signal from the
419
527
Mandos server object."""
421
529
client = self.clients_dict[path]
422
530
except KeyError:
423
531
# not found?
532
self.log_message("Unknown client {0!r} ({1!r}) removed"
533
.format(name, path))
424
534
return
425
self.remove_client(client, path)
535
client.delete()
426
536
427
def add_new_client(self, path, properties):
537
def add_new_client(self, path):
428
538
client_proxy_object = self.bus.get_object(self.busname, path)
429
539
self.add_client(MandosClientWidget(server_proxy_object
430
540
=self.mandos_serv,
431
541
proxy_object
432
542
=client_proxy_object,
433
properties=properties,
434
543
update_hook
435
544
=self.refresh,
436
545
delete_hook
437
=self.remove_client),
546
=self.remove_client,
547
logger
548
=self.log_message),
438
549
path=path)
439
550
440
551
def add_client(self, client, path=None):
442
553
if path is None:
443
554
path = client.proxy.object_path
444
555
self.clients_dict[path] = client
445
self.clients.sort(None, lambda c: c.properties[u"name"])
556
self.clients.sort(key=lambda c: c.properties["Name"])
446
557
self.refresh()
447
558
448
559
def remove_client(self, client, path=None):
450
561
if path is None:
451
562
path = client.proxy.object_path
452
563
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
564
self.refresh()
459
565
460
566
def refresh(self):
464
570
465
571
def run(self):
466
572
"""Start the main loop and exit when it's done."""
573
self.bus = dbus.SystemBus()
574
mandos_dbus_objc = self.bus.get_object(
575
self.busname, "/", follow_name_owner_changes=True)
576
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
577
dbus_interface
578
= server_interface)
579
try:
580
mandos_clients = (self.mandos_serv
581
.GetAllClientsWithProperties())
582
if not mandos_clients:
583
self.log_message_raw(("bold", "Note: Server has no clients."))
584
except dbus.exceptions.DBusException:
585
self.log_message_raw(("bold", "Note: No Mandos server running."))
586
mandos_clients = dbus.Dictionary()
587
588
(self.mandos_serv
589
.connect_to_signal("ClientRemoved",
590
self.find_and_remove_client,
591
dbus_interface=server_interface,
592
byte_arrays=True))
593
(self.mandos_serv
594
.connect_to_signal("ClientAdded",
595
self.add_new_client,
596
dbus_interface=server_interface,
597
byte_arrays=True))
598
(self.mandos_serv
599
.connect_to_signal("ClientNotFound",
600
self.client_not_found,
601
dbus_interface=server_interface,
602
byte_arrays=True))
603
for path, client in mandos_clients.items():
604
client_proxy_object = self.bus.get_object(self.busname,
605
path)
606
self.add_client(MandosClientWidget(server_proxy_object
607
=self.mandos_serv,
608
proxy_object
609
=client_proxy_object,
610
properties=client,
611
update_hook
612
=self.refresh,
613
delete_hook
614
=self.remove_client,
615
logger
616
=self.log_message),
617
path=path)
618
467
619
self.refresh()
468
620
self._input_callback_tag = (gobject.io_add_watch
469
621
(sys.stdin.fileno(),
479
631
480
632
def process_input(self, source, condition):
481
633
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
634
translations = { "ctrl n": "down", # Emacs
635
"ctrl p": "up", # Emacs
636
"ctrl v": "page down", # Emacs
637
"meta v": "page up", # Emacs
638
" ": "page down", # less
639
"f": "page down", # less
640
"b": "page up", # less
641
"j": "down", # vi
642
"k": "up", # vi
491
643
}
492
644
for key in keys:
493
645
try:
495
647
except KeyError: # :-)
496
648
pass
497
649
498
if key == u"q" or key == u"Q":
650
if key == "q" or key == "Q":
499
651
self.stop()
500
652
break
501
elif key == u"window resize":
653
elif key == "window resize":
502
654
self.size = self.screen.get_cols_rows()
503
655
self.refresh()
504
elif key == u"\f": # Ctrl-L
656
elif key == "\f": # Ctrl-L
505
657
self.refresh()
506
elif key == u"l" or key == u"D":
658
elif key == "l" or key == "D":
507
659
self.toggle_log_display()
508
660
self.refresh()
509
elif key == u"w" or key == u"i":
661
elif key == "w" or key == "i":
510
662
self.change_log_display()
511
663
self.refresh()
512
elif key == u"?" or key == u"f1" or key == u"esc":
664
elif key == "?" or key == "f1" or key == "esc":
513
665
if not self.log_visible:
514
666
self.log_visible = True
515
667
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"))))
668
self.log_message_raw(("bold",
669
" ".
670
join(("q: Quit",
671
"?: Help",
672
"l: Log window toggle",
673
"TAB: Switch window",
674
"w: Wrap (log)"))))
675
self.log_message_raw(("bold",
676
" "
677
.join(("Clients:",
678
"+: Enable",
679
"-: Disable",
680
"R: Remove",
681
"s: Start new checker",
682
"S: Stop checker",
683
"C: Checker OK",
684
"a: Approve",
685
"d: Deny"))))
532
686
self.refresh()
533
elif key == u"tab":
687
elif key == "tab":
534
688
if self.topwidget.get_focus() is self.logbox:
535
689
self.topwidget.set_focus(0)
536
690
else:
537
691
self.topwidget.set_focus(self.logbox)
538
692
self.refresh()
539
#elif (key == u"end" or key == u"meta >" or key == u"G"
540
# or key == u">"):
693
#elif (key == "end" or key == "meta >" or key == "G"
694
# or key == ">"):
541
695
# pass # xxx end-of-buffer
542
#elif (key == u"home" or key == u"meta <" or key == u"g"
543
# or key == u"<"):
696
#elif (key == "home" or key == "meta <" or key == "g"
697
# or key == "<"):
544
698
# pass # xxx beginning-of-buffer
545
#elif key == u"ctrl e" or key == u"$":
699
#elif key == "ctrl e" or key == "$":
546
700
# pass # xxx move-end-of-line
547
#elif key == u"ctrl a" or key == u"^":
701
#elif key == "ctrl a" or key == "^":
548
702
# pass # xxx move-beginning-of-line
549
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
703
#elif key == "ctrl b" or key == "meta (" or key == "h":
550
704
# pass # xxx left
551
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
705
#elif key == "ctrl f" or key == "meta )" or key == "l":
552
706
# pass # xxx right
553
#elif key == u"a":
707
#elif key == "a":
554
708
# pass # scroll up log
555
#elif key == u"z":
709
#elif key == "z":
556
710
# pass # scroll down log
557
711
elif self.topwidget.selectable():
558
712
self.topwidget.keypress(self.size, key)
562
716
ui = UserInterface()
563
717
try:
564
718
ui.run()
565
except:
719
except KeyboardInterrupt:
720
ui.screen.stop()
721
except Exception as e:
722
ui.log_message(str(e))
566
723
ui.screen.stop()
567
724
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0