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