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