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 410
- compare with another revision
- download diff
- download tarball
- view history from revision 410
- Committer: Teddy Hogeborn
- Date: 2009-11-19 18:31:28 UTC
- Revision ID: teddy@fukt.bsnet.se-20091119183128-ttstewh61xmtnil1
* Makefile (LINK_FORTIFY_LD): Bug fix: removed "-fPIE".
* mandos-keygen: Bug fix: Fix quoting for the "--password" option.
* mandos-keygen: Bug fix: Fix quoting for the "--password" option.
- 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
49
import locale
50
51
if sys.version_info[0] == 2:
52
str = unicode
53
54
locale.setlocale(locale.LC_ALL, '')
55
56
import logging
57
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
20
import UserList
58
21
59
22
# Some useful constants
60
domain = 'se.recompile'
23
domain = 'se.bsnet.fukt'
61
24
server_interface = domain + '.Mandos'
62
25
client_interface = domain + '.Mandos.Client'
63
version = "1.6.5"
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
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)
80
35
81
36
class MandosClientPropertyCache(object):
82
37
"""This wraps a Mandos Client D-Bus proxy object, caches the
83
38
properties and calls a hook function when any of them are
84
39
changed.
85
40
"""
86
def __init__(self, proxy_object=None, properties=None, **kwargs):
41
def __init__(self, proxy_object=None, properties=None, *args,
42
**kwargs):
87
43
self.proxy = proxy_object # Mandos Client proxy object
88
self.properties = dict() if properties is None else properties
89
self.property_changed_match = (
90
self.proxy.connect_to_signal("PropertyChanged",
91
self._property_changed,
92
client_interface,
93
byte_arrays=True))
94
95
if properties is None:
96
self.properties.update(
97
self.proxy.GetAll(client_interface,
98
dbus_interface
99
= dbus.PROPERTIES_IFACE))
100
101
super(MandosClientPropertyCache, self).__init__(**kwargs)
102
103
def _property_changed(self, property, value):
104
"""Helper which takes positional arguments"""
105
return self.property_changed(property=property, value=value)
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)
106
61
107
62
def property_changed(self, property=None, value=None):
108
63
"""This is called whenever we get a PropertyChanged signal
110
65
"""
111
66
# Update properties dict with new value
112
67
self.properties[property] = value
113
114
def delete(self):
115
self.property_changed_match.remove()
116
68
117
69
118
70
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
120
72
"""
121
73
122
74
def __init__(self, server_proxy_object=None, update_hook=None,
123
delete_hook=None, logger=None, **kwargs):
75
delete_hook=None, logger=None, *args, **kwargs):
124
76
# Called on update
125
77
self.update_hook = update_hook
126
78
# Called on delete
130
82
# Logger
131
83
self.logger = logger
132
84
133
self._update_timer_callback_tag = None
134
135
85
# The widget shown normally
136
self._text_widget = urwid.Text("")
86
self._text_widget = urwid.Text(u"")
137
87
# The widget shown when we have focus
138
self._focus_text_widget = urwid.Text("")
139
super(MandosClientWidget, self).__init__(**kwargs)
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)
140
92
self.update()
141
93
self.opened = False
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 {0}'
165
# .format(self.properties["Name"]))
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
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)
179
110
180
111
def checker_completed(self, exitstatus, condition, command):
181
112
if exitstatus == 0:
182
self.update()
113
self.logger(u'Checker for client %s (command "%s")'
114
u' was successful'
115
% (self.properties[u"name"], command))
183
116
return
184
# Checker failed
185
117
if os.WIFEXITED(condition):
186
self.logger('Checker for client {0} (command "{1}")'
187
' failed with exit code {2}'
188
.format(self.properties["Name"], command,
189
os.WEXITSTATUS(condition)))
190
elif os.WIFSIGNALED(condition):
191
self.logger('Checker for client {0} (command "{1}") was'
192
' killed by signal {2}'
193
.format(self.properties["Name"], command,
194
os.WTERMSIG(condition)))
195
elif os.WCOREDUMP(condition):
196
self.logger('Checker for client {0} (command "{1}")'
197
' dumped core'
198
.format(self.properties["Name"], command))
199
else:
200
self.logger('Checker for client {0} completed'
201
' mysteriously'
202
.format(self.properties["Name"]))
203
self.update()
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')
204
134
205
135
def checker_started(self, command):
206
"""Server signals that a checker started. This could be useful
207
to log in the future. """
208
#self.logger('Client {0} started checker "{1}"'
209
# .format(self.properties["Name"],
210
# str(command)))
211
pass
136
self.logger(u'Client %s started checker "%s"'
137
% (self.properties[u"name"], unicode(command)))
212
138
213
139
def got_secret(self):
214
self.logger('Client {0} received its secret'
215
.format(self.properties["Name"]))
216
217
def need_approval(self, timeout, default):
218
if not default:
219
message = 'Client {0} needs approval within {1} seconds'
220
else:
221
message = 'Client {0} will get its secret in {1} seconds'
222
self.logger(message.format(self.properties["Name"],
223
timeout/1000))
224
225
def rejected(self, reason):
226
self.logger('Client {0} was rejected; reason: {1}'
227
.format(self.properties["Name"], reason))
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"])
228
146
229
147
def selectable(self):
230
148
"""Make this a "selectable" widget.
231
149
This overrides the method from urwid.FlowWidget."""
232
150
return True
233
151
234
def rows(self, maxcolrow, focus=False):
152
def rows(self, (maxcol,), focus=False):
235
153
"""How many rows this widget will occupy might depend on
236
154
whether we have focus or not.
237
155
This overrides the method from urwid.FlowWidget"""
238
return self.current_widget(focus).rows(maxcolrow, focus=focus)
156
return self.current_widget(focus).rows((maxcol,), focus=focus)
239
157
240
158
def current_widget(self, focus=False):
241
159
if focus or self.opened:
245
163
def update(self):
246
164
"Called when what is visible on the screen should be updated."
247
165
# How to add standout mode to a style
248
with_standout = { "normal": "standout",
249
"bold": "bold-standout",
250
"underline-blink":
251
"underline-blink-standout",
252
"bold-underline-blink":
253
"bold-underline-blink-standout",
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",
254
172
}
255
173
256
174
# Rebuild focus and non-focus widgets using current properties
257
258
# Base part of a client. Name!
259
base = '{name}: '.format(name=self.properties["Name"])
260
if not self.properties["Enabled"]:
261
message = "DISABLED"
262
self.using_timer(False)
263
elif self.properties["ApprovalPending"]:
264
timeout = datetime.timedelta(milliseconds
265
= self.properties
266
["ApprovalDelay"])
267
last_approval_request = isoformat_to_datetime(
268
self.properties["LastApprovalRequest"])
269
if last_approval_request is not None:
270
timer = max(timeout - (datetime.datetime.utcnow()
271
- last_approval_request),
272
datetime.timedelta())
273
else:
274
timer = datetime.timedelta()
275
if self.properties["ApprovedByDefault"]:
276
message = "Approval in {0}. (d)eny?"
277
else:
278
message = "Denial in {0}. (a)pprove?"
279
message = message.format(str(timer).rsplit(".", 1)[0])
280
self.using_timer(True)
281
elif self.properties["LastCheckerStatus"] != 0:
282
# When checker has failed, show timer until client expires
283
expires = self.properties["Expires"]
284
if expires == "":
285
timer = datetime.timedelta(0)
286
else:
287
expires = (datetime.datetime.strptime
288
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
289
timer = max(expires - datetime.datetime.utcnow(),
290
datetime.timedelta())
291
message = ('A checker has failed! Time until client'
292
' gets disabled: {0}'
293
.format(str(timer).rsplit(".", 1)[0]))
294
self.using_timer(True)
295
else:
296
message = "enabled"
297
self.using_timer(False)
298
self._text = "{0}{1}".format(base, message)
299
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")})
300
181
if not urwid.supports_unicode():
301
182
self._text = self._text.encode("ascii", "replace")
302
textlist = [("normal", self._text)]
183
textlist = [(u"normal", self._text)]
303
184
self._text_widget.set_text(textlist)
304
185
self._focus_text_widget.set_text([(with_standout[text[0]],
305
186
text[1])
313
194
if self.update_hook is not None:
314
195
self.update_hook()
315
196
316
def update_timer(self):
317
"""called by gobject. Will indefinitely loop until
318
gobject.source_remove() on tag is called"""
319
self.update()
320
return True # Keep calling this
321
322
def delete(self, **kwargs):
323
if self._update_timer_callback_tag is not None:
324
gobject.source_remove(self._update_timer_callback_tag)
325
self._update_timer_callback_tag = None
326
for match in self.match_objects:
327
match.remove()
328
self.match_objects = ()
197
def delete(self):
329
198
if self.delete_hook is not None:
330
199
self.delete_hook(self)
331
return super(MandosClientWidget, self).delete(**kwargs)
332
200
333
def render(self, maxcolrow, focus=False):
201
def render(self, (maxcol,), focus=False):
334
202
"""Render differently if we have focus.
335
203
This overrides the method from urwid.FlowWidget"""
336
return self.current_widget(focus).render(maxcolrow,
204
return self.current_widget(focus).render((maxcol,),
337
205
focus=focus)
338
206
339
def keypress(self, maxcolrow, key):
207
def keypress(self, (maxcol,), key):
340
208
"""Handle keys.
341
209
This overrides the method from urwid.FlowWidget"""
342
if key == "+":
343
self.proxy.Enable(dbus_interface = client_interface,
344
ignore_reply=True)
345
elif key == "-":
346
self.proxy.Disable(dbus_interface = client_interface,
347
ignore_reply=True)
348
elif key == "a":
349
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
350
dbus_interface = client_interface,
351
ignore_reply=True)
352
elif key == "d":
353
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
354
dbus_interface = client_interface,
355
ignore_reply=True)
356
elif key == "R" or key == "_" or key == "ctrl k":
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":
357
215
self.server_proxy_object.RemoveClient(self.proxy
358
.object_path,
359
ignore_reply=True)
360
elif key == "s":
361
self.proxy.StartChecker(dbus_interface = client_interface,
362
ignore_reply=True)
363
elif key == "S":
364
self.proxy.StopChecker(dbus_interface = client_interface,
365
ignore_reply=True)
366
elif key == "C":
367
self.proxy.CheckedOK(dbus_interface = client_interface,
368
ignore_reply=True)
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()
369
223
# xxx
370
# elif key == "p" or key == "=":
224
# elif key == u"p" or key == "=":
371
225
# self.proxy.pause()
372
# elif key == "u" or key == ":":
226
# elif key == u"u" or key == ":":
373
227
# self.proxy.unpause()
374
# elif key == "RET":
228
# elif key == u"RET":
375
229
# self.open()
376
230
else:
377
231
return key
378
232
379
def property_changed(self, property=None, **kwargs):
233
def property_changed(self, property=None, value=None,
234
*args, **kwargs):
380
235
"""Call self.update() if old value is not new value.
381
236
This overrides the method from MandosClientPropertyCache"""
382
property_name = str(property)
237
property_name = unicode(property)
383
238
old_value = self.properties.get(property_name)
384
239
super(MandosClientWidget, self).property_changed(
385
property=property, **kwargs)
240
property=property, value=value, *args, **kwargs)
386
241
if self.properties.get(property_name) != old_value:
387
242
self.update()
388
243
392
247
"down" key presses, thus not allowing any containing widgets to
393
248
use them as an excuse to shift focus away from this widget.
394
249
"""
395
def keypress(self, *args, **kwargs):
396
ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
397
if ret in ("up", "down"):
250
def keypress(self, (maxcol, maxrow), key):
251
ret = super(ConstrainedListBox, self).keypress((maxcol, maxrow), key)
252
if ret in (u"up", u"down"):
398
253
return
399
254
return ret
400
255
409
264
self.screen = urwid.curses_display.Screen()
410
265
411
266
self.screen.register_palette((
412
("normal",
413
"default", "default", None),
414
("bold",
415
"bold", "default", "bold"),
416
("underline-blink",
417
"underline,blink", "default", "underline,blink"),
418
("standout",
419
"standout", "default", "standout"),
420
("bold-underline-blink",
421
"bold,underline,blink", "default", "bold,underline,blink"),
422
("bold-standout",
423
"bold,standout", "default", "bold,standout"),
424
("underline-blink-standout",
425
"underline,blink,standout", "default",
426
"underline,blink,standout"),
427
("bold-underline-blink-standout",
428
"bold,underline,blink,standout", "default",
429
"bold,underline,blink,standout"),
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")),
430
284
))
431
285
432
286
if urwid.supports_unicode():
433
self.divider = "─" # \u2500
434
#self.divider = "━" # \u2501
287
self.divider = u"─" # \u2500
288
#self.divider = u"━" # \u2501
435
289
else:
436
#self.divider = "-" # \u002d
437
self.divider = "_" # \u005f
290
#self.divider = u"-" # \u002d
291
self.divider = u"_" # \u005f
438
292
439
293
self.screen.start()
440
294
454
308
# This keeps track of whether self.uilist currently has
455
309
# self.logbox in it or not
456
310
self.log_visible = True
457
self.log_wrap = "any"
311
self.log_wrap = u"any"
458
312
459
313
self.rebuild()
460
self.log_message_raw(("bold",
461
"Mandos Monitor version " + version))
462
self.log_message_raw(("bold",
463
"q: Quit ?: Help"))
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"))
464
318
465
319
self.busname = domain + '.Mandos'
466
320
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)
467
363
468
364
def client_not_found(self, fingerprint, address):
469
self.log_message("Client with address {0} and fingerprint"
470
" {1} could not be found"
471
.format(address, fingerprint))
365
self.log_message((u"Client with address %s and fingerprint %s"
366
u" could not be found" % (address,
367
fingerprint)))
472
368
473
369
def rebuild(self):
474
370
"""This rebuilds the User Interface.
475
371
Call this when the widget layout needs to change"""
476
372
self.uilist = []
477
373
#self.uilist.append(urwid.ListBox(self.clients))
478
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
479
clients),
374
self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),
480
375
#header=urwid.Divider(),
481
376
header=None,
482
footer=
483
urwid.Divider(div_char=
484
self.divider)))
377
footer=urwid.Divider(div_char=self.divider)))
485
378
if self.log_visible:
486
379
self.uilist.append(self.logbox)
380
pass
487
381
self.topwidget = urwid.Pile(self.uilist)
488
382
489
383
def log_message(self, message):
490
"""Log message formatted with timestamp"""
491
384
timestamp = datetime.datetime.now().isoformat()
492
self.log_message_raw(timestamp + ": " + message)
385
self.log_message_raw(timestamp + u": " + message)
493
386
494
387
def log_message_raw(self, markup):
495
388
"""Add a log message to the log buffer."""
498
391
and len(self.log) > self.max_log_length):
499
392
del self.log[0:len(self.log)-self.max_log_length-1]
500
393
self.logbox.set_focus(len(self.logbox.body.contents),
501
coming_from="above")
394
coming_from=u"above")
502
395
self.refresh()
503
396
504
397
def toggle_log_display(self):
505
398
"""Toggle visibility of the log buffer."""
506
399
self.log_visible = not self.log_visible
507
400
self.rebuild()
508
#self.log_message("Log visibility changed to: "
509
# + str(self.log_visible))
401
self.log_message(u"Log visibility changed to: "
402
+ unicode(self.log_visible))
510
403
511
404
def change_log_display(self):
512
405
"""Change type of log display.
513
406
Currently, this toggles wrapping of text lines."""
514
if self.log_wrap == "clip":
515
self.log_wrap = "any"
407
if self.log_wrap == u"clip":
408
self.log_wrap = u"any"
516
409
else:
517
self.log_wrap = "clip"
410
self.log_wrap = u"clip"
518
411
for textwidget in self.log:
519
412
textwidget.set_wrap_mode(self.log_wrap)
520
#self.log_message("Wrap mode: " + self.log_wrap)
413
self.log_message(u"Wrap mode: " + self.log_wrap)
521
414
522
415
def find_and_remove_client(self, path, name):
523
"""Find a client by its object path and remove it.
416
"""Find an client from its object path and remove it.
524
417
525
418
This is connected to the ClientRemoved signal from the
526
419
Mandos server object."""
528
421
client = self.clients_dict[path]
529
422
except KeyError:
530
423
# not found?
531
self.log_message("Unknown client {0!r} ({1!r}) removed"
532
.format(name, path))
533
424
return
534
client.delete()
425
self.remove_client(client, path)
535
426
536
def add_new_client(self, path):
427
def add_new_client(self, path, properties):
537
428
client_proxy_object = self.bus.get_object(self.busname, path)
538
429
self.add_client(MandosClientWidget(server_proxy_object
539
430
=self.mandos_serv,
540
431
proxy_object
541
432
=client_proxy_object,
433
properties=properties,
542
434
update_hook
543
435
=self.refresh,
544
436
delete_hook
545
=self.remove_client,
546
logger
547
=self.log_message),
437
=self.remove_client),
548
438
path=path)
549
439
550
440
def add_client(self, client, path=None):
552
442
if path is None:
553
443
path = client.proxy.object_path
554
444
self.clients_dict[path] = client
555
self.clients.sort(key=lambda c: c.properties["Name"])
445
self.clients.sort(None, lambda c: c.properties[u"name"])
556
446
self.refresh()
557
447
558
448
def remove_client(self, client, path=None):
560
450
if path is None:
561
451
path = client.proxy.object_path
562
452
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()
563
458
self.refresh()
564
459
565
460
def refresh(self):
569
464
570
465
def run(self):
571
466
"""Start the main loop and exit when it's done."""
572
self.bus = dbus.SystemBus()
573
mandos_dbus_objc = self.bus.get_object(
574
self.busname, "/", follow_name_owner_changes=True)
575
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
576
dbus_interface
577
= server_interface)
578
try:
579
mandos_clients = (self.mandos_serv
580
.GetAllClientsWithProperties())
581
if not mandos_clients:
582
self.log_message_raw(("bold", "Note: Server has no clients."))
583
except dbus.exceptions.DBusException:
584
self.log_message_raw(("bold", "Note: No Mandos server running."))
585
mandos_clients = dbus.Dictionary()
586
587
(self.mandos_serv
588
.connect_to_signal("ClientRemoved",
589
self.find_and_remove_client,
590
dbus_interface=server_interface,
591
byte_arrays=True))
592
(self.mandos_serv
593
.connect_to_signal("ClientAdded",
594
self.add_new_client,
595
dbus_interface=server_interface,
596
byte_arrays=True))
597
(self.mandos_serv
598
.connect_to_signal("ClientNotFound",
599
self.client_not_found,
600
dbus_interface=server_interface,
601
byte_arrays=True))
602
for path, client in mandos_clients.items():
603
client_proxy_object = self.bus.get_object(self.busname,
604
path)
605
self.add_client(MandosClientWidget(server_proxy_object
606
=self.mandos_serv,
607
proxy_object
608
=client_proxy_object,
609
properties=client,
610
update_hook
611
=self.refresh,
612
delete_hook
613
=self.remove_client,
614
logger
615
=self.log_message),
616
path=path)
617
618
467
self.refresh()
619
468
self._input_callback_tag = (gobject.io_add_watch
620
469
(sys.stdin.fileno(),
630
479
631
480
def process_input(self, source, condition):
632
481
keys = self.screen.get_input()
633
translations = { "ctrl n": "down", # Emacs
634
"ctrl p": "up", # Emacs
635
"ctrl v": "page down", # Emacs
636
"meta v": "page up", # Emacs
637
" ": "page down", # less
638
"f": "page down", # less
639
"b": "page up", # less
640
"j": "down", # vi
641
"k": "up", # vi
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
491
}
643
492
for key in keys:
644
493
try:
646
495
except KeyError: # :-)
647
496
pass
648
497
649
if key == "q" or key == "Q":
498
if key == u"q" or key == u"Q":
650
499
self.stop()
651
500
break
652
elif key == "window resize":
501
elif key == u"window resize":
653
502
self.size = self.screen.get_cols_rows()
654
503
self.refresh()
655
elif key == "\f": # Ctrl-L
504
elif key == u"\f": # Ctrl-L
656
505
self.refresh()
657
elif key == "l" or key == "D":
506
elif key == u"l" or key == u"D":
658
507
self.toggle_log_display()
659
508
self.refresh()
660
elif key == "w" or key == "i":
509
elif key == u"w" or key == u"i":
661
510
self.change_log_display()
662
511
self.refresh()
663
elif key == "?" or key == "f1" or key == "esc":
512
elif key == u"?" or key == u"f1" or key == u"esc":
664
513
if not self.log_visible:
665
514
self.log_visible = True
666
515
self.rebuild()
667
self.log_message_raw(("bold",
668
" ".
669
join(("q: Quit",
670
"?: Help",
671
"l: Log window toggle",
672
"TAB: Switch window",
673
"w: Wrap (log)"))))
674
self.log_message_raw(("bold",
675
" "
676
.join(("Clients:",
677
"+: Enable",
678
"-: Disable",
679
"R: Remove",
680
"s: Start new checker",
681
"S: Stop checker",
682
"C: Checker OK",
683
"a: Approve",
684
"d: Deny"))))
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"))))
685
532
self.refresh()
686
elif key == "tab":
533
elif key == u"tab":
687
534
if self.topwidget.get_focus() is self.logbox:
688
535
self.topwidget.set_focus(0)
689
536
else:
690
537
self.topwidget.set_focus(self.logbox)
691
538
self.refresh()
692
#elif (key == "end" or key == "meta >" or key == "G"
693
# or key == ">"):
539
#elif (key == u"end" or key == u"meta >" or key == u"G"
540
# or key == u">"):
694
541
# pass # xxx end-of-buffer
695
#elif (key == "home" or key == "meta <" or key == "g"
696
# or key == "<"):
542
#elif (key == u"home" or key == u"meta <" or key == u"g"
543
# or key == u"<"):
697
544
# pass # xxx beginning-of-buffer
698
#elif key == "ctrl e" or key == "$":
545
#elif key == u"ctrl e" or key == u"$":
699
546
# pass # xxx move-end-of-line
700
#elif key == "ctrl a" or key == "^":
547
#elif key == u"ctrl a" or key == u"^":
701
548
# pass # xxx move-beginning-of-line
702
#elif key == "ctrl b" or key == "meta (" or key == "h":
549
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
703
550
# pass # xxx left
704
#elif key == "ctrl f" or key == "meta )" or key == "l":
551
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
705
552
# pass # xxx right
706
#elif key == "a":
553
#elif key == u"a":
707
554
# pass # scroll up log
708
#elif key == "z":
555
#elif key == u"z":
709
556
# pass # scroll down log
710
557
elif self.topwidget.selectable():
711
558
self.topwidget.keypress(self.size, key)
715
562
ui = UserInterface()
716
563
try:
717
564
ui.run()
718
except KeyboardInterrupt:
719
ui.screen.stop()
720
except Exception as e:
721
ui.log_message(str(e))
565
except:
722
566
ui.screen.stop()
723
567
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0