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