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