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 237.4.31
- compare with another revision
- download diff
- download tarball
- view history from revision 237.4.31
- Committer: Teddy Hogeborn
- Date: 2012-05-20 13:52:09 UTC
- mfrom: (237.7.1 release)
- mto: (237.4.32 release)
- mto: This revision was merged to the branch mainline in revision 586.
- Revision ID: teddy@recompile.se-20120520135209-4qencnc8bx594u2u
Tags: version-1.5.4-1
* Makefile (version): Changed to "1.5.4".
* NEWS (Version 1.5.4): New entry.
* debian/changelog (1.5.4-1): - '' -
* NEWS (Version 1.5.4): New entry.
* debian/changelog (1.5.4-1): - '' -
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-2018 Teddy Hogeborn
7
# Copyright © 2009-2018 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.7.16"
63
64
try:
65
dbus.OBJECT_MANAGER_IFACE
66
except AttributeError:
67
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
68
58
version = "1.5.4"
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
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):
491
"""Log message formatted with timestamp"""
492
if level < self.log_level:
493
return
490
491
def log_message(self, message):
494
492
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):
493
self.log_message_raw(timestamp + ": " + message)
494
495
def log_message_raw(self, markup):
499
496
"""Add a log message to the log buffer."""
500
if level < self.log_level:
501
return
502
497
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]
498
if (self.max_log_length
499
and len(self.log) > self.max_log_length):
500
del self.log[0:len(self.log)-self.max_log_length-1]
506
501
self.logbox.set_focus(len(self.logbox.body.contents),
507
502
coming_from="above")
508
503
self.refresh()
509
504
510
505
def toggle_log_display(self):
511
506
"""Toggle visibility of the log buffer."""
512
507
self.log_visible = not self.log_visible
513
508
self.rebuild()
514
self.log_message("Log visibility changed to: {}"
515
.format(self.log_visible), level=0)
516
509
#self.log_message("Log visibility changed to: "
510
# + unicode(self.log_visible))
511
517
512
def change_log_display(self):
518
513
"""Change type of log display.
519
514
Currently, this toggles wrapping of text lines."""
523
518
self.log_wrap = "clip"
524
519
for textwidget in self.log:
525
520
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):
521
#self.log_message("Wrap mode: " + self.log_wrap)
522
523
def find_and_remove_client(self, path, name):
530
524
"""Find a client by its object path and remove it.
531
532
This is connected to the InterfacesRemoved signal from the
525
526
This is connected to the ClientRemoved signal from the
533
527
Mandos server object."""
534
if client_interface not in interfaces:
535
# Not a Mandos client object; ignore
536
return
537
528
try:
538
529
client = self.clients_dict[path]
539
530
except KeyError:
540
531
# not found?
541
self.log_message("Unknown client {!r} removed"
542
.format(path))
532
self.log_message("Unknown client {0!r} ({1!r}) removed"
533
.format(name, path))
543
534
return
544
535
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
536
537
def add_new_client(self, path):
555
538
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])),
539
self.add_client(MandosClientWidget(server_proxy_object
540
=self.mandos_serv,
541
proxy_object
542
=client_proxy_object,
543
update_hook
544
=self.refresh,
545
delete_hook
546
=self.remove_client,
547
logger
548
=self.log_message),
563
549
path=path)
564
550
565
551
def add_client(self, client, path=None):
566
552
self.clients.append(client)
567
553
if path is None:
568
554
path = client.proxy.object_path
569
555
self.clients_dict[path] = client
570
self.clients.sort(key=lambda c: c.properties["Name"])
556
self.clients.sort(None, lambda c: c.properties["Name"])
571
557
self.refresh()
572
558
573
559
def remove_client(self, client, path=None):
574
560
self.clients.remove(client)
575
561
if path is None:
576
562
path = client.proxy.object_path
577
563
del self.clients_dict[path]
564
if not self.clients_dict:
565
# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
566
# is completely emptied, we need to recreate it.
567
self.clients = urwid.SimpleListWalker([])
568
self.rebuild()
578
569
self.refresh()
579
570
580
571
def refresh(self):
581
572
"""Redraw the screen"""
582
573
canvas = self.topwidget.render(self.size, focus=True)
583
574
self.screen.draw_screen(self.size, canvas)
584
575
585
576
def run(self):
586
577
"""Start the main loop and exit when it's done."""
587
578
self.bus = dbus.SystemBus()
588
579
mandos_dbus_objc = self.bus.get_object(
589
580
self.busname, "/", follow_name_owner_changes=True)
590
self.mandos_serv = dbus.Interface(
591
mandos_dbus_objc, dbus_interface=server_interface)
581
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
582
dbus_interface
583
= server_interface)
592
584
try:
593
585
mandos_clients = (self.mandos_serv
594
586
.GetAllClientsWithProperties())
595
if not mandos_clients:
596
self.log_message_raw(("bold",
597
"Note: Server has no clients."))
598
587
except dbus.exceptions.DBusException:
599
self.log_message_raw(("bold",
600
"Note: No Mandos server running."))
601
588
mandos_clients = dbus.Dictionary()
602
589
603
590
(self.mandos_serv
604
.connect_to_signal("InterfacesRemoved",
591
.connect_to_signal("ClientRemoved",
605
592
self.find_and_remove_client,
606
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
593
dbus_interface=server_interface,
607
594
byte_arrays=True))
608
595
(self.mandos_serv
609
.connect_to_signal("InterfacesAdded",
596
.connect_to_signal("ClientAdded",
610
597
self.add_new_client,
611
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
598
dbus_interface=server_interface,
612
599
byte_arrays=True))
613
600
(self.mandos_serv
614
601
.connect_to_signal("ClientNotFound",
615
602
self.client_not_found,
616
603
dbus_interface=server_interface,
617
604
byte_arrays=True))
618
for path, client in mandos_clients.items():
605
for path, client in mandos_clients.iteritems():
619
606
client_proxy_object = self.bus.get_object(self.busname,
620
607
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),
608
self.add_client(MandosClientWidget(server_proxy_object
609
=self.mandos_serv,
610
proxy_object
611
=client_proxy_object,
612
properties=client,
613
update_hook
614
=self.refresh,
615
delete_hook
616
=self.remove_client,
617
logger
618
=self.log_message),
628
619
path=path)
629
620
630
621
self.refresh()
631
self._input_callback_tag = (GLib.io_add_watch
622
self._input_callback_tag = (gobject.io_add_watch
632
623
(sys.stdin.fileno(),
633
GLib.IO_IN,
624
gobject.IO_IN,
634
625
self.process_input))
635
626
self.main_loop.run()
636
627
# Main loop has finished, we should close everything now
637
GLib.source_remove(self._input_callback_tag)
628
gobject.source_remove(self._input_callback_tag)
638
629
self.screen.stop()
639
630
640
631
def stop(self):
641
632
self.main_loop.quit()
642
633
643
634
def process_input(self, source, condition):
644
635
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
}
636
translations = { "ctrl n": "down", # Emacs
637
"ctrl p": "up", # Emacs
638
"ctrl v": "page down", # Emacs
639
"meta v": "page up", # Emacs
640
" ": "page down", # less
641
"f": "page down", # less
642
"b": "page up", # less
643
"j": "down", # vi
644
"k": "up", # vi
645
}
655
646
for key in keys:
656
647
try:
657
648
key = translations[key]
658
649
except KeyError: # :-)
659
650
pass
660
651
661
652
if key == "q" or key == "Q":
662
653
self.stop()
663
654
break
664
655
elif key == "window resize":
665
656
self.size = self.screen.get_cols_rows()
666
657
self.refresh()
667
elif key == "ctrl l":
668
self.screen.clear()
658
elif key == "\f": # Ctrl-L
669
659
self.refresh()
670
660
elif key == "l" or key == "D":
671
661
self.toggle_log_display()
683
673
"?: Help",
684
674
"l: Log window toggle",
685
675
"TAB: Switch window",
686
"w: Wrap (log lines)",
687
"v: Toggle verbose log",
688
))))
676
"w: Wrap (log)"))))
689
677
self.log_message_raw(("bold",
690
678
" "
691
679
.join(("Clients:",
704
692
else:
705
693
self.topwidget.set_focus(self.logbox)
706
694
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
695
#elif (key == "end" or key == "meta >" or key == "G"
696
# or key == ">"):
697
# pass # xxx end-of-buffer
698
#elif (key == "home" or key == "meta <" or key == "g"
699
# or key == "<"):
700
# pass # xxx beginning-of-buffer
701
#elif key == "ctrl e" or key == "$":
702
# pass # xxx move-end-of-line
703
#elif key == "ctrl a" or key == "^":
704
# pass # xxx move-beginning-of-line
705
#elif key == "ctrl b" or key == "meta (" or key == "h":
706
# pass # xxx left
707
#elif key == "ctrl f" or key == "meta )" or key == "l":
708
# pass # xxx right
709
#elif key == "a":
710
# pass # scroll up log
711
#elif key == "z":
712
# pass # scroll down log
732
713
elif self.topwidget.selectable():
733
714
self.topwidget.keypress(self.size, key)
734
715
self.refresh()
735
716
return True
736
717
737
738
718
ui = UserInterface()
739
719
try:
740
720
ui.run()
741
721
except KeyboardInterrupt:
742
722
ui.screen.stop()
743
except Exception as e:
744
ui.log_message(str(e))
723
except Exception, e:
724
ui.log_message(unicode(e))
745
725
ui.screen.stop()
746
726
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0