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.158
- compare with another revision
- download diff
- download tarball
- view history from revision 24.1.158
- Committer: Björn Påhlsson
- Date: 2010-09-07 20:22:16 UTC
- mto: (237.4.3 mandos-release)
- mto: This revision was merged to the branch mainline in revision 421.
- Revision ID: belorn@fukt.bsnet.se-20100907202216-vypcn3nsd02mqz4s
mandos-monitor: removed milisecondsseconds from countdown.
- files added:
- plugins.d/plymouth
- 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-2011 Teddy Hogeborn
7
# Copyright © 2009-2011 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.4.1"
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
134
105
self.last_checker_failed = False
135
106
136
107
# The widget shown normally
137
self._text_widget = urwid.Text("")
108
self._text_widget = urwid.Text(u"")
138
109
# The widget shown when we have focus
139
self._focus_text_widget = urwid.Text("")
110
self._focus_text_widget = urwid.Text(u"")
140
111
super(MandosClientWidget, self).__init__(
141
112
update_hook=update_hook, delete_hook=delete_hook,
142
113
*args, **kwargs)
143
114
self.update()
144
115
self.opened = False
145
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)
146
136
last_checked_ok = isoformat_to_datetime(self.properties
147
["LastCheckedOK"])
137
["last_checked_ok"])
148
138
if last_checked_ok is None:
149
139
self.last_checker_failed = True
150
140
else:
152
142
- last_checked_ok)
153
143
> datetime.timedelta
154
144
(milliseconds=
155
self.properties
156
["Interval"]))
157
145
self.properties["interval"]))
158
146
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
147
self._update_timer_callback_tag = (gobject.timeout_add
205
148
(1000,
206
149
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
210
150
211
151
def checker_completed(self, exitstatus, condition, command):
212
152
if exitstatus == 0:
213
153
if self.last_checker_failed:
214
154
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))
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))
219
160
self.update()
220
161
return
221
162
# Checker failed
222
163
if not self.last_checker_failed:
223
164
self.last_checker_failed = True
224
self.using_timer(True)
165
self._update_timer_callback_tag = (gobject.timeout_add
166
(1000,
167
self.update_timer))
225
168
if os.WIFEXITED(condition):
226
self.logger('Checker for client %s (command "%s")'
227
' failed with exit code %s'
228
% (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,
229
172
os.WEXITSTATUS(condition)))
230
173
elif os.WIFSIGNALED(condition):
231
self.logger('Checker for client %s (command "%s")'
232
' was killed by signal %s'
233
% (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,
234
177
os.WTERMSIG(condition)))
235
178
elif os.WCOREDUMP(condition):
236
self.logger('Checker for client %s (command "%s")'
237
' dumped core'
238
% (self.properties["Name"], command))
179
self.logger(u'Checker for client %s (command "%s")'
180
u' dumped core'
181
% (self.properties[u"name"], command))
239
182
else:
240
self.logger('Checker for client %s completed'
241
' mysteriously')
183
self.logger(u'Checker for client %s completed mysteriously')
242
184
self.update()
243
185
244
186
def checker_started(self, 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)))
187
#self.logger(u'Client %s started checker "%s"'
188
# % (self.properties[u"name"], unicode(command)))
249
189
pass
250
190
251
191
def got_secret(self):
252
self.last_checker_failed = False
253
self.logger('Client %s received its secret'
254
% self.properties["Name"])
192
self.logger(u'Client %s received its secret'
193
% self.properties[u"name"])
255
194
256
195
def need_approval(self, timeout, default):
257
196
if not default:
258
message = 'Client %s needs approval within %s seconds'
197
message = u'Client %s needs approval within %s seconds'
259
198
else:
260
message = 'Client %s will get its secret in %s seconds'
199
message = u'Client %s will get its secret in %s seconds'
261
200
self.logger(message
262
% (self.properties["Name"], timeout/1000))
263
self.using_timer(True)
201
% (self.properties[u"name"], timeout/1000))
264
202
265
203
def rejected(self, reason):
266
self.logger('Client %s was rejected; reason: %s'
267
% (self.properties["Name"], reason))
204
self.logger(u'Client %s was rejected; reason: %s'
205
% (self.properties[u"name"], reason))
268
206
269
207
def selectable(self):
270
208
"""Make this a "selectable" widget.
271
209
This overrides the method from urwid.FlowWidget."""
272
210
return True
273
211
274
def rows(self, maxcolrow, focus=False):
212
def rows(self, (maxcol,), focus=False):
275
213
"""How many rows this widget will occupy might depend on
276
214
whether we have focus or not.
277
215
This overrides the method from urwid.FlowWidget"""
278
return self.current_widget(focus).rows(maxcolrow, focus=focus)
216
return self.current_widget(focus).rows((maxcol,), focus=focus)
279
217
280
218
def current_widget(self, focus=False):
281
219
if focus or self.opened:
285
223
def update(self):
286
224
"Called when what is visible on the screen should be updated."
287
225
# How to add standout mode to a style
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",
226
with_standout = { u"normal": u"standout",
227
u"bold": u"bold-standout",
228
u"underline-blink":
229
u"underline-blink-standout",
230
u"bold-underline-blink":
231
u"bold-underline-blink-standout",
294
232
}
295
233
296
234
# Rebuild focus and non-focus widgets using current properties
297
235
298
236
# Base part of a client. Name!
299
base = ('%(name)s: '
300
% {"name": self.properties["Name"]})
301
if not self.properties["Enabled"]:
302
message = "DISABLED"
303
elif self.properties["ApprovalPending"]:
237
base = (u'%(name)s: '
238
% {u"name": self.properties[u"name"]})
239
if not self.properties[u"enabled"]:
240
message = u"DISABLED"
241
elif self.last_checker_failed:
304
242
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'
243
= self.properties[u"timeout"])
244
last_ok = isoformat_to_datetime(
245
max((self.properties["last_checked_ok"]
246
or self.properties["created"]),
247
self.properties[u"last_enabled"]))
248
timer = timeout - (datetime.datetime.utcnow() - last_ok)
249
message = (u'A checker has failed! Time until client gets diabled: %s'
330
250
% unicode(timer).rsplit(".", 1)[0])
251
elif self.properties[u"approved_pending"]:
252
if self.properties[u"approved_by_default"]:
253
message = u"Connection established to client. (d)eny?"
254
else:
255
message = u"Seeks approval to send secret. (a)pprove?"
331
256
else:
332
message = "enabled"
257
message = u"enabled"
333
258
self._text = "%s%s" % (base, message)
334
259
335
260
if not urwid.supports_unicode():
336
261
self._text = self._text.encode("ascii", "replace")
337
textlist = [("normal", self._text)]
262
textlist = [(u"normal", self._text)]
338
263
self._text_widget.set_text(textlist)
339
264
self._focus_text_widget.set_text([(with_standout[text[0]],
340
265
text[1])
349
274
self.update_hook()
350
275
351
276
def update_timer(self):
352
"""called by gobject. Will indefinitely loop until
353
gobject.source_remove() on tag is called"""
277
"called by gobject"
354
278
self.update()
355
279
return True # Keep calling this
356
280
357
def delete(self, *args, **kwargs):
281
def delete(self):
358
282
if self._update_timer_callback_tag is not None:
359
283
gobject.source_remove(self._update_timer_callback_tag)
360
284
self._update_timer_callback_tag = None
361
for match in self.match_objects:
362
match.remove()
363
self.match_objects = ()
364
285
if self.delete_hook is not None:
365
286
self.delete_hook(self)
366
return super(MandosClientWidget, self).delete(*args, **kwargs)
367
287
368
def render(self, maxcolrow, focus=False):
288
def render(self, (maxcol,), focus=False):
369
289
"""Render differently if we have focus.
370
290
This overrides the method from urwid.FlowWidget"""
371
return self.current_widget(focus).render(maxcolrow,
291
return self.current_widget(focus).render((maxcol,),
372
292
focus=focus)
373
293
374
def keypress(self, maxcolrow, key):
294
def keypress(self, (maxcol,), key):
375
295
"""Handle keys.
376
296
This overrides the method from urwid.FlowWidget"""
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":
297
if key == u"+":
298
self.proxy.Enable(dbus_interface = client_interface)
299
elif key == u"-":
300
self.proxy.Disable(dbus_interface = client_interface)
301
elif key == u"a":
384
302
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
385
dbus_interface = client_interface,
386
ignore_reply=True)
387
elif key == "d":
303
dbus_interface = client_interface)
304
elif key == u"d":
388
305
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
389
dbus_interface = client_interface,
390
ignore_reply=True)
391
elif key == "R" or key == "_" or key == "ctrl k":
306
dbus_interface = client_interface)
307
elif key == u"r" or key == u"_" or key == u"ctrl k":
392
308
self.server_proxy_object.RemoveClient(self.proxy
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)
309
.object_path)
310
elif key == u"s":
311
self.proxy.StartChecker(dbus_interface = client_interface)
312
elif key == u"S":
313
self.proxy.StopChecker(dbus_interface = client_interface)
314
elif key == u"C":
315
self.proxy.CheckedOK(dbus_interface = client_interface)
404
316
# xxx
405
# elif key == "p" or key == "=":
317
# elif key == u"p" or key == "=":
406
318
# self.proxy.pause()
407
# elif key == "u" or key == ":":
319
# elif key == u"u" or key == ":":
408
320
# self.proxy.unpause()
409
# elif key == "RET":
321
# elif key == u"RET":
410
322
# self.open()
323
# elif key == u"+":
324
# self.proxy.Approve(True)
325
# elif key == u"-":
326
# self.proxy.Approve(False)
411
327
else:
412
328
return key
413
329
428
344
"down" key presses, thus not allowing any containing widgets to
429
345
use them as an excuse to shift focus away from this widget.
430
346
"""
431
def keypress(self, maxcolrow, key):
432
ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)
433
if ret in ("up", "down"):
347
def keypress(self, (maxcol, maxrow), key):
348
ret = super(ConstrainedListBox, self).keypress((maxcol, maxrow), key)
349
if ret in (u"up", u"down"):
434
350
return
435
351
return ret
436
352
445
361
self.screen = urwid.curses_display.Screen()
446
362
447
363
self.screen.register_palette((
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")),
364
(u"normal",
365
u"default", u"default", None),
366
(u"bold",
367
u"default", u"default", u"bold"),
368
(u"underline-blink",
369
u"default", u"default", u"underline"),
370
(u"standout",
371
u"default", u"default", u"standout"),
372
(u"bold-underline-blink",
373
u"default", u"default", (u"bold", u"underline")),
374
(u"bold-standout",
375
u"default", u"default", (u"bold", u"standout")),
376
(u"underline-blink-standout",
377
u"default", u"default", (u"underline", u"standout")),
378
(u"bold-underline-blink-standout",
379
u"default", u"default", (u"bold", u"underline",
380
u"standout")),
465
381
))
466
382
467
383
if urwid.supports_unicode():
468
self.divider = "─" # \u2500
469
#self.divider = "━" # \u2501
384
self.divider = u"─" # \u2500
385
#self.divider = u"━" # \u2501
470
386
else:
471
#self.divider = "-" # \u002d
472
self.divider = "_" # \u005f
387
#self.divider = u"-" # \u002d
388
self.divider = u"_" # \u005f
473
389
474
390
self.screen.start()
475
391
489
405
# This keeps track of whether self.uilist currently has
490
406
# self.logbox in it or not
491
407
self.log_visible = True
492
self.log_wrap = "any"
408
self.log_wrap = u"any"
493
409
494
410
self.rebuild()
495
self.log_message_raw(("bold",
496
"Mandos Monitor version " + version))
497
self.log_message_raw(("bold",
498
"q: Quit ?: Help"))
411
self.log_message_raw((u"bold",
412
u"Mandos Monitor version " + version))
413
self.log_message_raw((u"bold",
414
u"q: Quit ?: Help"))
499
415
500
416
self.busname = domain + '.Mandos'
501
417
self.main_loop = gobject.MainLoop()
418
self.bus = dbus.SystemBus()
419
mandos_dbus_objc = self.bus.get_object(
420
self.busname, u"/", follow_name_owner_changes=True)
421
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
422
dbus_interface
423
= server_interface)
424
try:
425
mandos_clients = (self.mandos_serv
426
.GetAllClientsWithProperties())
427
except dbus.exceptions.DBusException:
428
mandos_clients = dbus.Dictionary()
429
430
(self.mandos_serv
431
.connect_to_signal(u"ClientRemoved",
432
self.find_and_remove_client,
433
dbus_interface=server_interface,
434
byte_arrays=True))
435
(self.mandos_serv
436
.connect_to_signal(u"ClientAdded",
437
self.add_new_client,
438
dbus_interface=server_interface,
439
byte_arrays=True))
440
(self.mandos_serv
441
.connect_to_signal(u"ClientNotFound",
442
self.client_not_found,
443
dbus_interface=server_interface,
444
byte_arrays=True))
445
for path, client in mandos_clients.iteritems():
446
client_proxy_object = self.bus.get_object(self.busname,
447
path)
448
self.add_client(MandosClientWidget(server_proxy_object
449
=self.mandos_serv,
450
proxy_object
451
=client_proxy_object,
452
properties=client,
453
update_hook
454
=self.refresh,
455
delete_hook
456
=self.remove_client,
457
logger
458
=self.log_message),
459
path=path)
502
460
503
461
def client_not_found(self, fingerprint, address):
504
self.log_message(("Client with address %s and fingerprint %s"
505
" could not be found" % (address,
462
self.log_message((u"Client with address %s and fingerprint %s"
463
u" could not be found" % (address,
506
464
fingerprint)))
507
465
508
466
def rebuild(self):
510
468
Call this when the widget layout needs to change"""
511
469
self.uilist = []
512
470
#self.uilist.append(urwid.ListBox(self.clients))
513
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
514
clients),
471
self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),
515
472
#header=urwid.Divider(),
516
473
header=None,
517
footer=
518
urwid.Divider(div_char=
519
self.divider)))
474
footer=urwid.Divider(div_char=self.divider)))
520
475
if self.log_visible:
521
476
self.uilist.append(self.logbox)
477
pass
522
478
self.topwidget = urwid.Pile(self.uilist)
523
479
524
480
def log_message(self, message):
525
481
timestamp = datetime.datetime.now().isoformat()
526
self.log_message_raw(timestamp + ": " + message)
482
self.log_message_raw(timestamp + u": " + message)
527
483
528
484
def log_message_raw(self, markup):
529
485
"""Add a log message to the log buffer."""
532
488
and len(self.log) > self.max_log_length):
533
489
del self.log[0:len(self.log)-self.max_log_length-1]
534
490
self.logbox.set_focus(len(self.logbox.body.contents),
535
coming_from="above")
491
coming_from=u"above")
536
492
self.refresh()
537
493
538
494
def toggle_log_display(self):
539
495
"""Toggle visibility of the log buffer."""
540
496
self.log_visible = not self.log_visible
541
497
self.rebuild()
542
#self.log_message("Log visibility changed to: "
543
# + unicode(self.log_visible))
498
self.log_message(u"Log visibility changed to: "
499
+ unicode(self.log_visible))
544
500
545
501
def change_log_display(self):
546
502
"""Change type of log display.
547
503
Currently, this toggles wrapping of text lines."""
548
if self.log_wrap == "clip":
549
self.log_wrap = "any"
504
if self.log_wrap == u"clip":
505
self.log_wrap = u"any"
550
506
else:
551
self.log_wrap = "clip"
507
self.log_wrap = u"clip"
552
508
for textwidget in self.log:
553
509
textwidget.set_wrap_mode(self.log_wrap)
554
#self.log_message("Wrap mode: " + self.log_wrap)
510
self.log_message(u"Wrap mode: " + self.log_wrap)
555
511
556
512
def find_and_remove_client(self, path, name):
557
"""Find a client by its object path and remove it.
513
"""Find an client from its object path and remove it.
558
514
559
515
This is connected to the ClientRemoved signal from the
560
516
Mandos server object."""
562
518
client = self.clients_dict[path]
563
519
except KeyError:
564
520
# not found?
565
self.log_message("Unknown client %r (%r) removed", name,
566
path)
567
521
return
568
client.delete()
522
self.remove_client(client, path)
569
523
570
524
def add_new_client(self, path):
571
525
client_proxy_object = self.bus.get_object(self.busname, path)
586
540
if path is None:
587
541
path = client.proxy.object_path
588
542
self.clients_dict[path] = client
589
self.clients.sort(None, lambda c: c.properties["Name"])
543
self.clients.sort(None, lambda c: c.properties[u"name"])
590
544
self.refresh()
591
545
592
546
def remove_client(self, client, path=None):
608
562
609
563
def run(self):
610
564
"""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
654
565
self.refresh()
655
566
self._input_callback_tag = (gobject.io_add_watch
656
567
(sys.stdin.fileno(),
666
577
667
578
def process_input(self, source, condition):
668
579
keys = self.screen.get_input()
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
580
translations = { u"ctrl n": u"down", # Emacs
581
u"ctrl p": u"up", # Emacs
582
u"ctrl v": u"page down", # Emacs
583
u"meta v": u"page up", # Emacs
584
u" ": u"page down", # less
585
u"f": u"page down", # less
586
u"b": u"page up", # less
587
u"j": u"down", # vi
588
u"k": u"up", # vi
678
589
}
679
590
for key in keys:
680
591
try:
682
593
except KeyError: # :-)
683
594
pass
684
595
685
if key == "q" or key == "Q":
596
if key == u"q" or key == u"Q":
686
597
self.stop()
687
598
break
688
elif key == "window resize":
599
elif key == u"window resize":
689
600
self.size = self.screen.get_cols_rows()
690
601
self.refresh()
691
elif key == "\f": # Ctrl-L
602
elif key == u"\f": # Ctrl-L
692
603
self.refresh()
693
elif key == "l" or key == "D":
604
elif key == u"l" or key == u"D":
694
605
self.toggle_log_display()
695
606
self.refresh()
696
elif key == "w" or key == "i":
607
elif key == u"w" or key == u"i":
697
608
self.change_log_display()
698
609
self.refresh()
699
elif key == "?" or key == "f1" or key == "esc":
610
elif key == u"?" or key == u"f1" or key == u"esc":
700
611
if not self.log_visible:
701
612
self.log_visible = True
702
613
self.rebuild()
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"))))
614
self.log_message_raw((u"bold",
615
u" ".
616
join((u"q: Quit",
617
u"?: Help",
618
u"l: Log window toggle",
619
u"TAB: Switch window",
620
u"w: Wrap (log)"))))
621
self.log_message_raw((u"bold",
622
u" "
623
.join((u"Clients:",
624
u"+: Enable",
625
u"-: Disable",
626
u"r: Remove",
627
u"s: Start new checker",
628
u"S: Stop checker",
629
u"C: Checker OK",
630
u"a: Approve",
631
u"d: Deny"))))
721
632
self.refresh()
722
elif key == "tab":
633
elif key == u"tab":
723
634
if self.topwidget.get_focus() is self.logbox:
724
635
self.topwidget.set_focus(0)
725
636
else:
726
637
self.topwidget.set_focus(self.logbox)
727
638
self.refresh()
728
#elif (key == "end" or key == "meta >" or key == "G"
729
# or key == ">"):
639
#elif (key == u"end" or key == u"meta >" or key == u"G"
640
# or key == u">"):
730
641
# pass # xxx end-of-buffer
731
#elif (key == "home" or key == "meta <" or key == "g"
732
# or key == "<"):
642
#elif (key == u"home" or key == u"meta <" or key == u"g"
643
# or key == u"<"):
733
644
# pass # xxx beginning-of-buffer
734
#elif key == "ctrl e" or key == "$":
645
#elif key == u"ctrl e" or key == u"$":
735
646
# pass # xxx move-end-of-line
736
#elif key == "ctrl a" or key == "^":
647
#elif key == u"ctrl a" or key == u"^":
737
648
# pass # xxx move-beginning-of-line
738
#elif key == "ctrl b" or key == "meta (" or key == "h":
649
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
739
650
# pass # xxx left
740
#elif key == "ctrl f" or key == "meta )" or key == "l":
651
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
741
652
# pass # xxx right
742
#elif key == "a":
653
#elif key == u"a":
743
654
# pass # scroll up log
744
#elif key == "z":
655
#elif key == u"z":
745
656
# pass # scroll down log
746
657
elif self.topwidget.selectable():
747
658
self.topwidget.keypress(self.size, key)
751
662
ui = UserInterface()
752
663
try:
753
664
ui.run()
754
except KeyboardInterrupt:
755
ui.screen.stop()
756
665
except Exception, e:
757
666
ui.log_message(unicode(e))
758
667
ui.screen.stop()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0