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