2
2
# -*- mode: python; coding: utf-8 -*-
4
4
# Mandos Monitor - Control and monitor the Mandos server
6
# Copyright © 2009-2019 Teddy Hogeborn
7
# Copyright © 2009-2019 Björn Påhlsson
9
# This file is part of Mandos.
11
# Mandos is free software: you can redistribute it and/or modify it
12
# under the terms of the GNU General Public License as published by
6
# Copyright © 2009-2011 Teddy Hogeborn
7
# Copyright © 2009-2011 Björn Påhlsson
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
13
11
# the Free Software Foundation, either version 3 of the License, or
14
12
# (at your option) any later version.
16
# Mandos is distributed in the hope that it will be useful, but
17
# WITHOUT ANY WARRANTY; without even the implied warranty of
14
# This program is distributed in the hope that it will be useful,
15
# but WITHOUT ANY WARRANTY; without even the implied warranty of
18
16
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19
17
# GNU General Public License for more details.
21
19
# You should have received a copy of the GNU General Public License
22
# along with Mandos. If not, see <http://www.gnu.org/licenses/>.
24
# Contact the authors at <mandos@recompile.se>.
20
# along with this program. If not, see <http://www.gnu.org/licenses/>.
22
# Contact the authors at <mandos@fukt.bsnet.se>.
27
25
from __future__ import (division, absolute_import, print_function,
30
from future_builtins import *
39
34
import urwid.curses_display
42
37
from dbus.mainloop.glib import DBusGMainLoop
43
from gi.repository import GLib
46
locale.setlocale(locale.LC_ALL, '')
51
if sys.version_info.major == 2:
54
log = logging.getLogger(os.path.basename(sys.argv[0]))
55
logging.basicConfig(level="NOTSET", # Show all messages
56
format="%(message)s") # Show basic log messages
58
logging.captureWarnings(True) # Show warnings via the logging system
60
locale.setlocale(locale.LC_ALL, '')
62
49
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
64
51
# Some useful constants
65
domain = 'se.recompile'
52
domain = 'se.bsnet.fukt'
66
53
server_interface = domain + '.Mandos'
67
54
client_interface = domain + '.Mandos.Client'
71
dbus.OBJECT_MANAGER_IFACE
72
except AttributeError:
73
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
57
# Always run in monochrome mode
58
urwid.curses_display.curses.has_colors = lambda : False
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)
76
65
def isoformat_to_datetime(iso):
77
66
"Parse an ISO 8601 date string to a datetime.datetime()"
89
int(second), # Whole seconds
90
int(fraction*1000000)) # Microseconds
78
int(second), # Whole seconds
79
int(fraction*1000000)) # Microseconds
93
81
class MandosClientPropertyCache(object):
94
82
"""This wraps a Mandos Client D-Bus proxy object, caches the
95
83
properties and calls a hook function when any of them are
98
def __init__(self, proxy_object=None, properties=None, **kwargs):
99
self.proxy = proxy_object # Mandos Client proxy object
100
self.properties = dict() if properties is None else properties
86
def __init__(self, proxy_object=None, *args, **kwargs):
87
self.proxy = proxy_object # Mandos Client proxy object
89
self.properties = dict()
101
90
self.property_changed_match = (
102
self.proxy.connect_to_signal("PropertiesChanged",
103
self.properties_changed,
104
dbus.PROPERTIES_IFACE,
91
self.proxy.connect_to_signal("PropertyChanged",
92
self.property_changed,
105
94
byte_arrays=True))
107
if properties is None:
108
self.properties.update(self.proxy.GetAll(
110
dbus_interface=dbus.PROPERTIES_IFACE))
112
super(MandosClientPropertyCache, self).__init__(**kwargs)
114
def properties_changed(self, interface, properties, invalidated):
115
"""This is called whenever we get a PropertiesChanged signal
116
It updates the changed properties in the "properties" dict.
96
self.properties.update(
97
self.proxy.GetAll(client_interface,
98
dbus_interface = dbus.PROPERTIES_IFACE))
100
#XXX This breaks good super behaviour
101
# super(MandosClientPropertyCache, self).__init__(
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.
118
108
# Update properties dict with new value
119
if interface == client_interface:
120
self.properties.update(properties)
109
self.properties[property] = value
111
def delete(self, *args, **kwargs):
123
112
self.property_changed_match.remove()
113
super(MandosClientPropertyCache, self).__init__(
126
117
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
127
118
"""A Mandos Client which is visible on the screen.
130
121
def __init__(self, server_proxy_object=None, update_hook=None,
131
delete_hook=None, **kwargs):
122
delete_hook=None, logger=None, *args, **kwargs):
132
123
# Called on update
133
124
self.update_hook = update_hook
134
125
# Called on delete
135
126
self.delete_hook = delete_hook
136
127
# Mandos Server proxy object
137
128
self.server_proxy_object = server_proxy_object
139
132
self._update_timer_callback_tag = None
133
self._update_timer_callback_lock = 0
134
self.last_checker_failed = False
141
136
# The widget shown normally
142
137
self._text_widget = urwid.Text("")
143
138
# The widget shown when we have focus
144
139
self._focus_text_widget = urwid.Text("")
145
super(MandosClientWidget, self).__init__(**kwargs)
140
super(MandosClientWidget, self).__init__(
141
update_hook=update_hook, delete_hook=delete_hook,
147
144
self.opened = False
146
last_checked_ok = isoformat_to_datetime(self.properties
148
if last_checked_ok is None:
149
self.last_checker_failed = True
151
self.last_checker_failed = ((datetime.datetime.utcnow()
158
if self.last_checker_failed:
159
self.using_timer(True)
161
if self.need_approval:
162
self.using_timer(True)
149
164
self.match_objects = (
150
165
self.proxy.connect_to_signal("CheckerCompleted",
151
166
self.checker_completed,
168
183
client_interface,
169
184
byte_arrays=True))
170
log.debug('Created client %s', self.properties["Name"])
185
#self.logger('Created client %s' % (self.properties["Name"]))
187
def property_changed(self, property=None, value=None):
188
super(self, MandosClientWidget).property_changed(property,
190
if property == "ApprovalPending":
191
using_timer(bool(value))
172
193
def using_timer(self, flag):
173
194
"""Call this method with True or False when timer should be
174
195
activated or deactivated.
176
if flag and self._update_timer_callback_tag is None:
177
# Will update the shown timer value every second
178
self._update_timer_callback_tag = (
179
GLib.timeout_add(1000,
180
glib_safely(self.update_timer)))
181
elif not (flag or self._update_timer_callback_tag is None):
182
GLib.source_remove(self._update_timer_callback_tag)
197
old = self._update_timer_callback_lock
199
self._update_timer_callback_lock += 1
201
self._update_timer_callback_lock -= 1
202
if old == 0 and self._update_timer_callback_lock:
203
self._update_timer_callback_tag = (gobject.timeout_add
206
elif old and self._update_timer_callback_lock == 0:
207
gobject.source_remove(self._update_timer_callback_tag)
183
208
self._update_timer_callback_tag = None
185
210
def checker_completed(self, exitstatus, condition, command):
186
211
if exitstatus == 0:
187
log.debug('Checker for client %s (command "%s")'
188
' succeeded', self.properties["Name"], command)
212
if self.last_checker_failed:
213
self.last_checker_failed = False
214
self.using_timer(False)
215
#self.logger('Checker for client %s (command "%s")'
217
# % (self.properties["Name"], command))
221
if not self.last_checker_failed:
222
self.last_checker_failed = True
223
self.using_timer(True)
192
224
if os.WIFEXITED(condition):
193
log.info('Checker for client %s (command "%s") failed'
194
' with exit code %d', self.properties["Name"],
195
command, os.WEXITSTATUS(condition))
225
self.logger('Checker for client %s (command "%s")'
226
' failed with exit code %s'
227
% (self.properties["Name"], command,
228
os.WEXITSTATUS(condition)))
196
229
elif os.WIFSIGNALED(condition):
197
log.info('Checker for client %s (command "%s") was'
198
' killed by signal %d', self.properties["Name"],
199
command, os.WTERMSIG(condition))
230
self.logger('Checker for client %s (command "%s")'
231
' was killed by signal %s'
232
% (self.properties["Name"], command,
233
os.WTERMSIG(condition)))
234
elif os.WCOREDUMP(condition):
235
self.logger('Checker for client %s (command "%s")'
237
% (self.properties["Name"], command))
239
self.logger('Checker for client %s completed'
202
243
def checker_started(self, command):
203
"""Server signals that a checker started."""
204
log.debug('Client %s started checker "%s"',
205
self.properties["Name"], command)
244
#self.logger('Client %s started checker "%s"'
245
# % (self.properties["Name"], unicode(command)))
207
248
def got_secret(self):
208
log.info("Client %s received its secret",
209
self.properties["Name"])
249
self.last_checker_failed = False
250
self.logger('Client %s received its secret'
251
% self.properties["Name"])
211
253
def need_approval(self, timeout, default):
213
message = "Client %s needs approval within %f seconds"
255
message = 'Client %s needs approval within %s seconds'
215
message = "Client %s will get its secret in %f seconds"
216
log.info(message, self.properties["Name"], timeout/1000)
257
message = 'Client %s will get its secret in %s seconds'
259
% (self.properties["Name"], timeout/1000))
260
self.using_timer(True)
218
262
def rejected(self, reason):
219
log.info("Client %s was rejected; reason: %s",
220
self.properties["Name"], reason)
263
self.logger('Client %s was rejected; reason: %s'
264
% (self.properties["Name"], reason))
222
266
def selectable(self):
223
267
"""Make this a "selectable" widget.
224
268
This overrides the method from urwid.FlowWidget."""
227
271
def rows(self, maxcolrow, focus=False):
228
272
"""How many rows this widget will occupy might depend on
229
273
whether we have focus or not.
230
274
This overrides the method from urwid.FlowWidget"""
231
275
return self.current_widget(focus).rows(maxcolrow, focus=focus)
233
277
def current_widget(self, focus=False):
234
278
if focus or self.opened:
235
279
return self._focus_widget
236
280
return self._widget
238
282
def update(self):
239
283
"Called when what is visible on the screen should be updated."
240
284
# How to add standout mode to a style
241
with_standout = {"normal": "standout",
242
"bold": "bold-standout",
244
"underline-blink-standout",
245
"bold-underline-blink":
246
"bold-underline-blink-standout",
285
with_standout = { "normal": "standout",
286
"bold": "bold-standout",
288
"underline-blink-standout",
289
"bold-underline-blink":
290
"bold-underline-blink-standout",
249
293
# Rebuild focus and non-focus widgets using current properties
251
295
# Base part of a client. Name!
252
base = '{name}: '.format(name=self.properties["Name"])
297
% {"name": self.properties["Name"]})
253
298
if not self.properties["Enabled"]:
254
299
message = "DISABLED"
255
self.using_timer(False)
256
300
elif self.properties["ApprovalPending"]:
257
timeout = datetime.timedelta(
258
milliseconds=self.properties["ApprovalDelay"])
301
timeout = datetime.timedelta(milliseconds
259
304
last_approval_request = isoformat_to_datetime(
260
305
self.properties["LastApprovalRequest"])
261
306
if last_approval_request is not None:
262
timer = max(timeout - (datetime.datetime.utcnow()
263
- last_approval_request),
264
datetime.timedelta())
307
timer = timeout - (datetime.datetime.utcnow()
308
- last_approval_request)
266
310
timer = datetime.timedelta()
267
311
if self.properties["ApprovedByDefault"]:
268
message = "Approval in {}. (d)eny?"
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"]
277
timer = datetime.timedelta(0)
279
expires = (datetime.datetime.strptime
280
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
281
timer = max(expires - datetime.datetime.utcnow(),
282
datetime.timedelta())
312
message = "Approval in %s. (d)eny?"
314
message = "Denial in %s. (a)pprove?"
315
message = message % unicode(timer).rsplit(".", 1)[0]
316
elif self.last_checker_failed:
317
timeout = datetime.timedelta(milliseconds
320
last_ok = isoformat_to_datetime(
321
max((self.properties["LastCheckedOK"]
322
or self.properties["Created"]),
323
self.properties["LastEnabled"]))
324
timer = timeout - (datetime.datetime.utcnow() - last_ok)
283
325
message = ('A checker has failed! Time until client'
285
.format(str(timer).rsplit(".", 1)[0]))
286
self.using_timer(True)
327
% unicode(timer).rsplit(".", 1)[0])
288
329
message = "enabled"
289
self.using_timer(False)
290
self._text = "{}{}".format(base, message)
330
self._text = "%s%s" % (base, message)
292
332
if not urwid.supports_unicode():
293
333
self._text = self._text.encode("ascii", "replace")
294
334
textlist = [("normal", self._text)]
304
344
# Run update hook, if any
305
345
if self.update_hook is not None:
306
346
self.update_hook()
308
348
def update_timer(self):
309
"""called by GLib. Will indefinitely loop until
310
GLib.source_remove() on tag is called
313
351
return True # Keep calling this
315
def delete(self, **kwargs):
353
def delete(self, *args, **kwargs):
316
354
if self._update_timer_callback_tag is not None:
317
GLib.source_remove(self._update_timer_callback_tag)
355
gobject.source_remove(self._update_timer_callback_tag)
318
356
self._update_timer_callback_tag = None
319
357
for match in self.match_objects:
321
359
self.match_objects = ()
322
360
if self.delete_hook is not None:
323
361
self.delete_hook(self)
324
return super(MandosClientWidget, self).delete(**kwargs)
362
return super(MandosClientWidget, self).delete(*args, **kwargs)
326
364
def render(self, maxcolrow, focus=False):
327
365
"""Render differently if we have focus.
328
366
This overrides the method from urwid.FlowWidget"""
329
367
return self.current_widget(focus).render(maxcolrow,
332
370
def keypress(self, maxcolrow, key):
334
372
This overrides the method from urwid.FlowWidget"""
336
self.proxy.Set(client_interface, "Enabled",
337
dbus.Boolean(True), ignore_reply=True,
338
dbus_interface=dbus.PROPERTIES_IFACE)
374
self.proxy.Enable(dbus_interface = client_interface,
340
self.proxy.Set(client_interface, "Enabled", False,
342
dbus_interface=dbus.PROPERTIES_IFACE)
377
self.proxy.Disable(dbus_interface = client_interface,
344
380
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
345
dbus_interface=client_interface,
381
dbus_interface = client_interface,
346
382
ignore_reply=True)
348
384
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
349
dbus_interface=client_interface,
385
dbus_interface = client_interface,
350
386
ignore_reply=True)
351
387
elif key == "R" or key == "_" or key == "ctrl k":
352
388
self.server_proxy_object.RemoveClient(self.proxy
354
390
ignore_reply=True)
356
self.proxy.Set(client_interface, "CheckerRunning",
357
dbus.Boolean(True), ignore_reply=True,
358
dbus_interface=dbus.PROPERTIES_IFACE)
392
self.proxy.StartChecker(dbus_interface = client_interface,
360
self.proxy.Set(client_interface, "CheckerRunning",
361
dbus.Boolean(False), ignore_reply=True,
362
dbus_interface=dbus.PROPERTIES_IFACE)
395
self.proxy.StopChecker(dbus_interface = client_interface,
364
self.proxy.CheckedOK(dbus_interface=client_interface,
398
self.proxy.CheckedOK(dbus_interface = client_interface,
365
399
ignore_reply=True)
367
401
# elif key == "p" or key == "=":
376
def properties_changed(self, interface, properties, invalidated):
377
"""Call self.update() if any properties changed.
410
def property_changed(self, property=None, value=None,
412
"""Call self.update() if old value is not new value.
378
413
This overrides the method from MandosClientPropertyCache"""
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):
414
property_name = unicode(property)
415
old_value = self.properties.get(property_name)
416
super(MandosClientWidget, self).property_changed(
417
property=property, value=value, *args, **kwargs)
418
if self.properties.get(property_name) != old_value:
388
def glib_safely(func, retval=True):
389
def safe_func(*args, **kwargs):
391
return func(*args, **kwargs)
398
422
class ConstrainedListBox(urwid.ListBox):
399
423
"""Like a normal urwid.ListBox, but will consume all "up" or
400
424
"down" key presses, thus not allowing any containing widgets to
401
425
use them as an excuse to shift focus away from this widget.
403
def keypress(self, *args, **kwargs):
404
ret = (super(ConstrainedListBox, self)
405
.keypress(*args, **kwargs))
427
def keypress(self, maxcolrow, key):
428
ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)
406
429
if ret in ("up", "down"):
415
438
def __init__(self, max_log_length=1000):
416
439
DBusGMainLoop(set_as_default=True)
418
441
self.screen = urwid.curses_display.Screen()
420
443
self.screen.register_palette((
422
445
"default", "default", None),
424
"bold", "default", "bold"),
447
"default", "default", "bold"),
425
448
("underline-blink",
426
"underline,blink", "default", "underline,blink"),
449
"default", "default", "underline"),
428
"standout", "default", "standout"),
451
"default", "default", "standout"),
429
452
("bold-underline-blink",
430
"bold,underline,blink", "default",
431
"bold,underline,blink"),
453
"default", "default", ("bold", "underline")),
432
454
("bold-standout",
433
"bold,standout", "default", "bold,standout"),
455
"default", "default", ("bold", "standout")),
434
456
("underline-blink-standout",
435
"underline,blink,standout", "default",
436
"underline,blink,standout"),
457
"default", "default", ("underline", "standout")),
437
458
("bold-underline-blink-standout",
438
"bold,underline,blink,standout", "default",
439
"bold,underline,blink,standout"),
459
"default", "default", ("bold", "underline",
442
463
if urwid.supports_unicode():
443
self.divider = "─" # \u2500
464
self.divider = "─" # \u2500
465
#self.divider = "━" # \u2501
445
self.divider = "_" # \u005f
467
#self.divider = "-" # \u002d
468
self.divider = "_" # \u005f
447
470
self.screen.start()
449
472
self.size = self.screen.get_cols_rows()
451
474
self.clients = urwid.SimpleListWalker([])
452
475
self.clients_dict = {}
454
477
# We will add Text widgets to this list
455
self.log = urwid.SimpleListWalker([])
456
479
self.max_log_length = max_log_length
458
481
# We keep a reference to the log widget so we can remove it
459
482
# from the ListWalker without it getting destroyed
460
483
self.logbox = ConstrainedListBox(self.log)
462
485
# This keeps track of whether self.uilist currently has
463
486
# self.logbox in it or not
464
487
self.log_visible = True
465
488
self.log_wrap = "any"
467
self.loghandler = UILogHandler(self)
470
self.add_log_line(("bold",
471
"Mandos Monitor version " + version))
472
self.add_log_line(("bold", "q: Quit ?: Help"))
491
self.log_message_raw(("bold",
492
"Mandos Monitor version " + version))
493
self.log_message_raw(("bold",
474
496
self.busname = domain + '.Mandos'
475
self.main_loop = GLib.MainLoop()
477
def client_not_found(self, key_id, address):
478
log.info("Client with address %s and key ID %s could"
479
" not be found", address, key_id)
497
self.main_loop = gobject.MainLoop()
498
self.bus = dbus.SystemBus()
499
mandos_dbus_objc = self.bus.get_object(
500
self.busname, "/", follow_name_owner_changes=True)
501
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
505
mandos_clients = (self.mandos_serv
506
.GetAllClientsWithProperties())
507
except dbus.exceptions.DBusException:
508
mandos_clients = dbus.Dictionary()
511
.connect_to_signal("ClientRemoved",
512
self.find_and_remove_client,
513
dbus_interface=server_interface,
516
.connect_to_signal("ClientAdded",
518
dbus_interface=server_interface,
521
.connect_to_signal("ClientNotFound",
522
self.client_not_found,
523
dbus_interface=server_interface,
525
for path, client in mandos_clients.iteritems():
526
client_proxy_object = self.bus.get_object(self.busname,
528
self.add_client(MandosClientWidget(server_proxy_object
531
=client_proxy_object,
541
def client_not_found(self, fingerprint, address):
542
self.log_message(("Client with address %s and fingerprint %s"
543
" could not be found" % (address,
481
546
def rebuild(self):
482
547
"""This rebuilds the User Interface.
483
548
Call this when the widget layout needs to change"""
485
# self.uilist.append(urwid.ListBox(self.clients))
550
#self.uilist.append(urwid.ListBox(self.clients))
486
551
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
488
# header=urwid.Divider(),
553
#header=urwid.Divider(),
490
footer=urwid.Divider(
491
div_char=self.divider)))
556
urwid.Divider(div_char=
492
558
if self.log_visible:
493
559
self.uilist.append(self.logbox)
494
561
self.topwidget = urwid.Pile(self.uilist)
496
def add_log_line(self, markup):
563
def log_message(self, message):
564
timestamp = datetime.datetime.now().isoformat()
565
self.log_message_raw(timestamp + ": " + message)
567
def log_message_raw(self, markup):
568
"""Add a log message to the log buffer."""
497
569
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
498
if self.max_log_length:
499
if len(self.log) > self.max_log_length:
500
del self.log[0:(len(self.log) - self.max_log_length)]
501
self.logbox.set_focus(len(self.logbox.body.contents)-1,
570
if (self.max_log_length
571
and len(self.log) > self.max_log_length):
572
del self.log[0:len(self.log)-self.max_log_length-1]
573
self.logbox.set_focus(len(self.logbox.body.contents),
502
574
coming_from="above")
505
577
def toggle_log_display(self):
506
578
"""Toggle visibility of the log buffer."""
507
579
self.log_visible = not self.log_visible
509
log.debug("Log visibility changed to: %s", self.log_visible)
581
#self.log_message("Log visibility changed to: "
582
# + unicode(self.log_visible))
511
584
def change_log_display(self):
512
585
"""Change type of log display.
513
586
Currently, this toggles wrapping of text lines."""
517
590
self.log_wrap = "clip"
518
591
for textwidget in self.log:
519
592
textwidget.set_wrap_mode(self.log_wrap)
520
log.debug("Wrap mode: %s", self.log_wrap)
522
def find_and_remove_client(self, path, interfaces):
593
#self.log_message("Wrap mode: " + self.log_wrap)
595
def find_and_remove_client(self, path, name):
523
596
"""Find a client by its object path and remove it.
525
This is connected to the InterfacesRemoved signal from the
598
This is connected to the ClientRemoved signal from the
526
599
Mandos server object."""
527
if client_interface not in interfaces:
528
# Not a Mandos client object; ignore
531
601
client = self.clients_dict[path]
534
log.warning("Unknown client %s removed", path)
604
self.log_message("Unknown client %r (%r) removed", name,
538
def add_new_client(self, path, ifs_and_props):
539
"""Find a client by its object path and remove it.
541
This is connected to the InterfacesAdded signal from the
542
Mandos server object.
544
if client_interface not in ifs_and_props:
545
# Not a Mandos client object; ignore
609
def add_new_client(self, path):
547
610
client_proxy_object = self.bus.get_object(self.busname, path)
548
self.add_client(MandosClientWidget(
549
server_proxy_object=self.mandos_serv,
550
proxy_object=client_proxy_object,
551
update_hook=self.refresh,
552
delete_hook=self.remove_client,
553
properties=dict(ifs_and_props[client_interface])),
611
self.add_client(MandosClientWidget(server_proxy_object
614
=client_proxy_object,
556
623
def add_client(self, client, path=None):
557
624
self.clients.append(client)
559
626
path = client.proxy.object_path
560
627
self.clients_dict[path] = client
561
self.clients.sort(key=lambda c: c.properties["Name"])
628
self.clients.sort(None, lambda c: c.properties["Name"])
564
631
def remove_client(self, client, path=None):
565
632
self.clients.remove(client)
567
634
path = client.proxy.object_path
568
635
del self.clients_dict[path]
636
if not self.clients_dict:
637
# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
638
# is completely emptied, we need to recreate it.
639
self.clients = urwid.SimpleListWalker([])
571
643
def refresh(self):
572
644
"""Redraw the screen"""
573
645
canvas = self.topwidget.render(self.size, focus=True)
574
646
self.screen.draw_screen(self.size, canvas)
577
649
"""Start the main loop and exit when it's done."""
578
log.addHandler(self.loghandler)
579
self.orig_log_propagate = log.propagate
580
log.propagate = False
581
self.orig_log_level = log.level
583
self.bus = dbus.SystemBus()
584
mandos_dbus_objc = self.bus.get_object(
585
self.busname, "/", follow_name_owner_changes=True)
586
self.mandos_serv = dbus.Interface(
587
mandos_dbus_objc, dbus_interface=server_interface)
589
mandos_clients = (self.mandos_serv
590
.GetAllClientsWithProperties())
591
if not mandos_clients:
592
log.warning("Note: Server has no clients.")
593
except dbus.exceptions.DBusException:
594
log.warning("Note: No Mandos server running.")
595
mandos_clients = dbus.Dictionary()
598
.connect_to_signal("InterfacesRemoved",
599
self.find_and_remove_client,
600
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
603
.connect_to_signal("InterfacesAdded",
605
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
608
.connect_to_signal("ClientNotFound",
609
self.client_not_found,
610
dbus_interface=server_interface,
612
for path, client in mandos_clients.items():
613
client_proxy_object = self.bus.get_object(self.busname,
615
self.add_client(MandosClientWidget(
616
server_proxy_object=self.mandos_serv,
617
proxy_object=client_proxy_object,
619
update_hook=self.refresh,
620
delete_hook=self.remove_client),
624
self._input_callback_tag = (
626
GLib.IOChannel.unix_new(sys.stdin.fileno()),
627
GLib.PRIORITY_DEFAULT, GLib.IO_IN,
628
glib_safely(self.process_input)))
651
self._input_callback_tag = (gobject.io_add_watch
629
655
self.main_loop.run()
630
656
# Main loop has finished, we should close everything now
631
GLib.source_remove(self._input_callback_tag)
632
with warnings.catch_warnings():
633
warnings.simplefilter("ignore", BytesWarning)
657
gobject.source_remove(self._input_callback_tag)
637
661
self.main_loop.quit()
638
log.removeHandler(self.loghandler)
639
log.propagate = self.orig_log_propagate
641
663
def process_input(self, source, condition):
642
664
keys = self.screen.get_input()
643
translations = {"ctrl n": "down", # Emacs
644
"ctrl p": "up", # Emacs
645
"ctrl v": "page down", # Emacs
646
"meta v": "page up", # Emacs
647
" ": "page down", # less
648
"f": "page down", # less
649
"b": "page up", # less
665
translations = { "ctrl n": "down", # Emacs
666
"ctrl p": "up", # Emacs
667
"ctrl v": "page down", # Emacs
668
"meta v": "page up", # Emacs
669
" ": "page down", # less
670
"f": "page down", # less
671
"b": "page up", # less
655
677
key = translations[key]
656
678
except KeyError: # :-)
659
681
if key == "q" or key == "Q":
662
684
elif key == "window resize":
663
685
self.size = self.screen.get_cols_rows()
665
elif key == "ctrl l":
687
elif key == "\f": # Ctrl-L
668
689
elif key == "l" or key == "D":
669
690
self.toggle_log_display()
702
722
self.topwidget.set_focus(self.logbox)
705
if log.level < logging.INFO:
706
log.setLevel(logging.INFO)
707
log.info("Verbose mode: Off")
709
log.setLevel(logging.NOTSET)
710
log.info("Verbose mode: On")
711
# elif (key == "end" or key == "meta >" or key == "G"
713
# pass # xxx end-of-buffer
714
# elif (key == "home" or key == "meta <" or key == "g"
716
# pass # xxx beginning-of-buffer
717
# elif key == "ctrl e" or key == "$":
718
# pass # xxx move-end-of-line
719
# elif key == "ctrl a" or key == "^":
720
# pass # xxx move-beginning-of-line
721
# elif key == "ctrl b" or key == "meta (" or key == "h":
723
# elif key == "ctrl f" or key == "meta )" or key == "l":
726
# pass # scroll up log
728
# pass # scroll down log
724
#elif (key == "end" or key == "meta >" or key == "G"
726
# pass # xxx end-of-buffer
727
#elif (key == "home" or key == "meta <" or key == "g"
729
# pass # xxx beginning-of-buffer
730
#elif key == "ctrl e" or key == "$":
731
# pass # xxx move-end-of-line
732
#elif key == "ctrl a" or key == "^":
733
# pass # xxx move-beginning-of-line
734
#elif key == "ctrl b" or key == "meta (" or key == "h":
736
#elif key == "ctrl f" or key == "meta )" or key == "l":
739
# pass # scroll up log
741
# pass # scroll down log
729
742
elif self.topwidget.selectable():
730
743
self.topwidget.keypress(self.size, key)
735
class UILogHandler(logging.Handler):
736
def __init__(self, ui, *args, **kwargs):
738
super(UILogHandler, self).__init__(*args, **kwargs)
740
logging.Formatter("%(asctime)s: %(message)s"))
741
def emit(self, record):
742
msg = self.format(record)
743
if record.levelno > logging.INFO:
745
self.ui.add_log_line(msg)
748
747
ui = UserInterface()
751
750
except KeyboardInterrupt:
752
with warnings.catch_warnings():
753
warnings.filterwarnings("ignore", "", BytesWarning)
756
with warnings.catch_warnings():
757
warnings.filterwarnings("ignore", "", BytesWarning)
753
ui.log_message(unicode(e))