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