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