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