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