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.24.1
- compare with another revision
- download diff
- download tarball
- view history from revision 237.24.1
- Committer: Teddy Hogeborn
- Date: 2015-05-23 20:18:34 UTC
- mto: (237.7.304 trunk)
- mto: This revision was merged to the branch mainline in revision 325.
- Revision ID: teddy@recompile.se-20150523201834-e89ex4ito93yni8x
mandos: Use multiprocessing module to run checkers.
For a long time, the Mandos server has occasionally logged the message
"ERROR: Child process vanished". This was never a fatal error, but it
has been annoying and slightly worrying, since a definite cause was
not found. One potential cause could be the "multiprocessing" and
"subprocess" modules conflicting w.r.t. SIGCHLD. To avoid this,
change the running of checkers from using subprocess.Popen
asynchronously to instead first create a multiprocessing.Process()
(which is asynchronous) calling a function, and have that function
then call subprocess.call() (which is synchronous). In this way, the
only thing using any asynchronous subprocesses is the multiprocessing
module.
This makes it necessary to change one small thing in the D-Bus API,
since the subprocesses.call() function does not expose the raw wait(2)
status value.
DBUS-API (CheckerCompleted): Change the second value provided by this
D-Bus signal from the raw wait(2) status
to the actual terminating signal number.
mandos (subprocess_call_pipe): New function to be called by
multiprocessing.Process (starting a
separate process).
(Client.last_checker signal): New attribute for signal which
terminated last checker. Like
last_checker_status, only not accessible
via D-Bus.
(Client.checker_callback): Take new "connection" argument and use it
to get returncode; set last_checker_signal.
Return False so gobject does not call this
callback again.
(Client.start_checker): Start checker using a multiprocessing.Process
instead of a subprocess.Popen.
(ClientDBus.checker_callback): Take new "connection" argument. Call
Client.checker_callback early to have
it set last_checker_status and
last_checker_signal; use those. Change
second value provided to D-Bus signal
CheckerCompleted to use
last_checker_signal if checker was
terminated by signal.
mandos-monitor: Update to reflect DBus API change.
(MandosClientWidget.checker_completed): Take "signal" instead of
"condition" argument. Use it
accordingly. Remove dead code
(os.WCOREDUMP case).
For a long time, the Mandos server has occasionally logged the message
"ERROR: Child process vanished". This was never a fatal error, but it
has been annoying and slightly worrying, since a definite cause was
not found. One potential cause could be the "multiprocessing" and
"subprocess" modules conflicting w.r.t. SIGCHLD. To avoid this,
change the running of checkers from using subprocess.Popen
asynchronously to instead first create a multiprocessing.Process()
(which is asynchronous) calling a function, and have that function
then call subprocess.call() (which is synchronous). In this way, the
only thing using any asynchronous subprocesses is the multiprocessing
module.
This makes it necessary to change one small thing in the D-Bus API,
since the subprocesses.call() function does not expose the raw wait(2)
status value.
DBUS-API (CheckerCompleted): Change the second value provided by this
D-Bus signal from the raw wait(2) status
to the actual terminating signal number.
mandos (subprocess_call_pipe): New function to be called by
multiprocessing.Process (starting a
separate process).
(Client.last_checker signal): New attribute for signal which
terminated last checker. Like
last_checker_status, only not accessible
via D-Bus.
(Client.checker_callback): Take new "connection" argument and use it
to get returncode; set last_checker_signal.
Return False so gobject does not call this
callback again.
(Client.start_checker): Start checker using a multiprocessing.Process
instead of a subprocess.Popen.
(ClientDBus.checker_callback): Take new "connection" argument. Call
Client.checker_callback early to have
it set last_checker_status and
last_checker_signal; use those. Change
second value provided to D-Bus signal
CheckerCompleted to use
last_checker_signal if checker was
terminated by signal.
mandos-monitor: Update to reflect DBus API change.
(MandosClientWidget.checker_completed): Take "signal" instead of
"condition" argument. Use it
accordingly. Remove dead code
(os.WCOREDUMP case).
- files added:
- initramfs-tools-hook-conf
- files removed:
- bugs.xml
- debian/tests
- dracut-module
- plugin-helpers
- files modified:
- .bzrignore
added
removed
mandos-monitor
1
#!/usr/bin/python3 -bb
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-2015 Teddy Hogeborn
7
# Copyright © 2009-2015 Björn Påhlsson
8
#
9
# This program is free software: you can redistribute it and/or modify
10
# it under the terms of the GNU General Public License as published by
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)
33
32
34
33
import sys
35
34
import os
36
import warnings
35
37
36
import datetime
38
37
39
38
import urwid.curses_display
40
39
import urwid
41
40
42
41
from dbus.mainloop.glib import DBusGMainLoop
43
from gi.repository import GLib
42
try:
43
import gobject
44
except ImportError:
45
from gi.repository import GObject as gobject
44
46
45
47
import dbus
46
48
47
49
import locale
48
50
49
import logging
50
51
51
if sys.version_info.major == 2:
52
52
str = unicode
53
53
54
54
locale.setlocale(locale.LC_ALL, '')
55
55
56
import logging
56
57
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
57
58
58
59
# Some useful constants
59
60
domain = 'se.recompile'
60
61
server_interface = domain + '.Mandos'
61
62
client_interface = domain + '.Mandos.Client'
62
version = "1.8.9"
63
64
try:
65
dbus.OBJECT_MANAGER_IFACE
66
except AttributeError:
67
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
68
63
version = "1.6.9"
69
64
70
65
def isoformat_to_datetime(iso):
71
66
"Parse an ISO 8601 date string to a datetime.datetime()"
80
75
int(day),
81
76
int(hour),
82
77
int(minute),
83
int(second), # Whole seconds
84
int(fraction*1000000)) # Microseconds
85
78
int(second), # Whole seconds
79
int(fraction*1000000)) # Microseconds
86
80
87
81
class MandosClientPropertyCache(object):
88
82
"""This wraps a Mandos Client D-Bus proxy object, caches the
90
84
changed.
91
85
"""
92
86
def __init__(self, proxy_object=None, properties=None, **kwargs):
93
self.proxy = proxy_object # Mandos Client proxy object
87
self.proxy = proxy_object # Mandos Client proxy object
94
88
self.properties = dict() if properties is None else properties
95
89
self.property_changed_match = (
96
90
self.proxy.connect_to_signal("PropertiesChanged",
97
91
self.properties_changed,
98
92
dbus.PROPERTIES_IFACE,
99
93
byte_arrays=True))
100
94
101
95
if properties is None:
102
self.properties.update(self.proxy.GetAll(
103
client_interface,
104
dbus_interface=dbus.PROPERTIES_IFACE))
105
96
self.properties.update(
97
self.proxy.GetAll(client_interface,
98
dbus_interface
99
= dbus.PROPERTIES_IFACE))
100
106
101
super(MandosClientPropertyCache, self).__init__(**kwargs)
107
102
108
103
def properties_changed(self, interface, properties, invalidated):
109
104
"""This is called whenever we get a PropertiesChanged signal
110
105
It updates the changed properties in the "properties" dict.
111
106
"""
112
107
# Update properties dict with new value
113
if interface == client_interface:
114
self.properties.update(properties)
115
108
self.properties.update(properties)
109
116
110
def delete(self):
117
111
self.property_changed_match.remove()
118
112
120
114
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
121
115
"""A Mandos Client which is visible on the screen.
122
116
"""
123
117
124
118
def __init__(self, server_proxy_object=None, update_hook=None,
125
119
delete_hook=None, logger=None, **kwargs):
126
120
# Called on update
131
125
self.server_proxy_object = server_proxy_object
132
126
# Logger
133
127
self.logger = logger
134
128
135
129
self._update_timer_callback_tag = None
136
130
137
131
# The widget shown normally
138
132
self._text_widget = urwid.Text("")
139
133
# The widget shown when we have focus
141
135
super(MandosClientWidget, self).__init__(**kwargs)
142
136
self.update()
143
137
self.opened = False
144
138
145
139
self.match_objects = (
146
140
self.proxy.connect_to_signal("CheckerCompleted",
147
141
self.checker_completed,
165
159
byte_arrays=True))
166
160
self.logger('Created client {}'
167
161
.format(self.properties["Name"]), level=0)
168
162
169
163
def using_timer(self, flag):
170
164
"""Call this method with True or False when timer should be
171
165
activated or deactivated.
172
166
"""
173
167
if flag and self._update_timer_callback_tag is None:
174
168
# Will update the shown timer value every second
175
self._update_timer_callback_tag = (GLib.timeout_add
169
self._update_timer_callback_tag = (gobject.timeout_add
176
170
(1000,
177
171
self.update_timer))
178
172
elif not (flag or self._update_timer_callback_tag is None):
179
GLib.source_remove(self._update_timer_callback_tag)
173
gobject.source_remove(self._update_timer_callback_tag)
180
174
self._update_timer_callback_tag = None
181
182
def checker_completed(self, exitstatus, condition, command):
175
176
def checker_completed(self, exitstatus, signal, command):
183
177
if exitstatus == 0:
184
178
self.logger('Checker for client {} (command "{}")'
185
179
' succeeded'.format(self.properties["Name"],
187
181
self.update()
188
182
return
189
183
# Checker failed
190
if os.WIFEXITED(condition):
184
if exitstatus >= 0:
191
185
self.logger('Checker for client {} (command "{}") failed'
192
186
' with exit code {}'
193
187
.format(self.properties["Name"], command,
194
os.WEXITSTATUS(condition)))
195
elif os.WIFSIGNALED(condition):
188
exitstatus))
189
elif signal != 0:
196
190
self.logger('Checker for client {} (command "{}") was'
197
191
' killed by signal {}'
198
192
.format(self.properties["Name"], command,
199
os.WTERMSIG(condition)))
193
signal))
194
else:
195
self.logger('Checker for client {} completed'
196
' mysteriously'
197
.format(self.properties["Name"]))
200
198
self.update()
201
199
202
200
def checker_started(self, command):
203
201
"""Server signals that a checker started."""
204
202
self.logger('Client {} started checker "{}"'
205
203
.format(self.properties["Name"],
206
204
command), level=0)
207
205
208
206
def got_secret(self):
209
207
self.logger('Client {} received its secret'
210
208
.format(self.properties["Name"]))
211
209
212
210
def need_approval(self, timeout, default):
213
211
if not default:
214
212
message = 'Client {} needs approval within {} seconds'
216
214
message = 'Client {} will get its secret in {} seconds'
217
215
self.logger(message.format(self.properties["Name"],
218
216
timeout/1000))
219
217
220
218
def rejected(self, reason):
221
219
self.logger('Client {} was rejected; reason: {}'
222
220
.format(self.properties["Name"], reason))
223
221
224
222
def selectable(self):
225
223
"""Make this a "selectable" widget.
226
224
This overrides the method from urwid.FlowWidget."""
227
225
return True
228
226
229
227
def rows(self, maxcolrow, focus=False):
230
228
"""How many rows this widget will occupy might depend on
231
229
whether we have focus or not.
232
230
This overrides the method from urwid.FlowWidget"""
233
231
return self.current_widget(focus).rows(maxcolrow, focus=focus)
234
232
235
233
def current_widget(self, focus=False):
236
234
if focus or self.opened:
237
235
return self._focus_widget
238
236
return self._widget
239
237
240
238
def update(self):
241
239
"Called when what is visible on the screen should be updated."
242
240
# 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
241
with_standout = { "normal": "standout",
242
"bold": "bold-standout",
243
"underline-blink":
244
"underline-blink-standout",
245
"bold-underline-blink":
246
"bold-underline-blink-standout",
247
}
248
251
249
# Rebuild focus and non-focus widgets using current properties
252
250
253
251
# Base part of a client. Name!
254
252
base = '{name}: '.format(name=self.properties["Name"])
255
253
if not self.properties["Enabled"]:
256
254
message = "DISABLED"
257
255
self.using_timer(False)
258
256
elif self.properties["ApprovalPending"]:
259
timeout = datetime.timedelta(
260
milliseconds=self.properties["ApprovalDelay"])
257
timeout = datetime.timedelta(milliseconds
258
= self.properties
259
["ApprovalDelay"])
261
260
last_approval_request = isoformat_to_datetime(
262
261
self.properties["LastApprovalRequest"])
263
262
if last_approval_request is not None:
290
289
message = "enabled"
291
290
self.using_timer(False)
292
291
self._text = "{}{}".format(base, message)
293
292
294
293
if not urwid.supports_unicode():
295
294
self._text = self._text.encode("ascii", "replace")
296
295
textlist = [("normal", self._text)]
306
305
# Run update hook, if any
307
306
if self.update_hook is not None:
308
307
self.update_hook()
309
308
310
309
def update_timer(self):
311
"""called by GLib. Will indefinitely loop until
312
GLib.source_remove() on tag is called
313
"""
310
"""called by gobject. Will indefinitely loop until
311
gobject.source_remove() on tag is called"""
314
312
self.update()
315
313
return True # Keep calling this
316
314
317
315
def delete(self, **kwargs):
318
316
if self._update_timer_callback_tag is not None:
319
GLib.source_remove(self._update_timer_callback_tag)
317
gobject.source_remove(self._update_timer_callback_tag)
320
318
self._update_timer_callback_tag = None
321
319
for match in self.match_objects:
322
320
match.remove()
324
322
if self.delete_hook is not None:
325
323
self.delete_hook(self)
326
324
return super(MandosClientWidget, self).delete(**kwargs)
327
325
328
326
def render(self, maxcolrow, focus=False):
329
327
"""Render differently if we have focus.
330
328
This overrides the method from urwid.FlowWidget"""
331
329
return self.current_widget(focus).render(maxcolrow,
332
330
focus=focus)
333
331
334
332
def keypress(self, maxcolrow, key):
335
333
"""Handle keys.
336
334
This overrides the method from urwid.FlowWidget"""
337
335
if key == "+":
338
self.proxy.Set(client_interface, "Enabled",
339
dbus.Boolean(True), ignore_reply=True,
340
dbus_interface=dbus.PROPERTIES_IFACE)
336
self.proxy.Enable(dbus_interface = client_interface,
337
ignore_reply=True)
341
338
elif key == "-":
342
self.proxy.Set(client_interface, "Enabled", False,
343
ignore_reply=True,
344
dbus_interface=dbus.PROPERTIES_IFACE)
339
self.proxy.Disable(dbus_interface = client_interface,
340
ignore_reply=True)
345
341
elif key == "a":
346
342
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
347
dbus_interface=client_interface,
343
dbus_interface = client_interface,
348
344
ignore_reply=True)
349
345
elif key == "d":
350
346
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
351
dbus_interface=client_interface,
347
dbus_interface = client_interface,
352
348
ignore_reply=True)
353
349
elif key == "R" or key == "_" or key == "ctrl k":
354
350
self.server_proxy_object.RemoveClient(self.proxy
355
351
.object_path,
356
352
ignore_reply=True)
357
353
elif key == "s":
358
self.proxy.Set(client_interface, "CheckerRunning",
359
dbus.Boolean(True), ignore_reply=True,
360
dbus_interface=dbus.PROPERTIES_IFACE)
354
self.proxy.StartChecker(dbus_interface = client_interface,
355
ignore_reply=True)
361
356
elif key == "S":
362
self.proxy.Set(client_interface, "CheckerRunning",
363
dbus.Boolean(False), ignore_reply=True,
364
dbus_interface=dbus.PROPERTIES_IFACE)
357
self.proxy.StopChecker(dbus_interface = client_interface,
358
ignore_reply=True)
365
359
elif key == "C":
366
self.proxy.CheckedOK(dbus_interface=client_interface,
360
self.proxy.CheckedOK(dbus_interface = client_interface,
367
361
ignore_reply=True)
368
362
# xxx
369
363
# elif key == "p" or key == "=":
374
368
# self.open()
375
369
else:
376
370
return key
377
371
378
372
def properties_changed(self, interface, properties, invalidated):
379
373
"""Call self.update() if any properties changed.
380
374
This overrides the method from MandosClientPropertyCache"""
381
old_values = {key: self.properties.get(key)
382
for key in properties.keys()}
375
old_values = { key: self.properties.get(key)
376
for key in properties.keys() }
383
377
super(MandosClientWidget, self).properties_changed(
384
378
interface, properties, invalidated)
385
379
if any(old_values[key] != self.properties.get(key)
393
387
use them as an excuse to shift focus away from this widget.
394
388
"""
395
389
def keypress(self, *args, **kwargs):
396
ret = (super(ConstrainedListBox, self)
397
.keypress(*args, **kwargs))
390
ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
398
391
if ret in ("up", "down"):
399
392
return
400
393
return ret
406
399
"""
407
400
def __init__(self, max_log_length=1000, log_level=1):
408
401
DBusGMainLoop(set_as_default=True)
409
402
410
403
self.screen = urwid.curses_display.Screen()
411
404
412
405
self.screen.register_palette((
413
406
("normal",
414
407
"default", "default", None),
419
412
("standout",
420
413
"standout", "default", "standout"),
421
414
("bold-underline-blink",
422
"bold,underline,blink", "default",
423
"bold,underline,blink"),
415
"bold,underline,blink", "default", "bold,underline,blink"),
424
416
("bold-standout",
425
417
"bold,standout", "default", "bold,standout"),
426
418
("underline-blink-standout",
430
422
"bold,underline,blink,standout", "default",
431
423
"bold,underline,blink,standout"),
432
424
))
433
425
434
426
if urwid.supports_unicode():
435
self.divider = "─" # \u2500
427
self.divider = "─" # \u2500
428
#self.divider = "━" # \u2501
436
429
else:
437
self.divider = "_" # \u005f
438
430
#self.divider = "-" # \u002d
431
self.divider = "_" # \u005f
432
439
433
self.screen.start()
440
434
441
435
self.size = self.screen.get_cols_rows()
442
436
443
437
self.clients = urwid.SimpleListWalker([])
444
438
self.clients_dict = {}
445
439
446
440
# We will add Text widgets to this list
447
self.log = urwid.SimpleListWalker([])
441
self.log = []
448
442
self.max_log_length = max_log_length
449
443
450
444
self.log_level = log_level
451
445
452
446
# We keep a reference to the log widget so we can remove it
453
447
# from the ListWalker without it getting destroyed
454
448
self.logbox = ConstrainedListBox(self.log)
455
449
456
450
# This keeps track of whether self.uilist currently has
457
451
# self.logbox in it or not
458
452
self.log_visible = True
459
453
self.log_wrap = "any"
460
454
461
455
self.rebuild()
462
456
self.log_message_raw(("bold",
463
457
"Mandos Monitor version " + version))
464
458
self.log_message_raw(("bold",
465
459
"q: Quit ?: Help"))
466
460
467
461
self.busname = domain + '.Mandos'
468
self.main_loop = GLib.MainLoop()
469
470
def client_not_found(self, key_id, address):
471
self.log_message("Client with address {} and key ID {} could"
472
" not be found".format(address, key_id))
473
462
self.main_loop = gobject.MainLoop()
463
464
def client_not_found(self, fingerprint, address):
465
self.log_message("Client with address {} and fingerprint {}"
466
" could not be found"
467
.format(address, fingerprint))
468
474
469
def rebuild(self):
475
470
"""This rebuilds the User Interface.
476
471
Call this when the widget layout needs to change"""
477
472
self.uilist = []
478
# self.uilist.append(urwid.ListBox(self.clients))
473
#self.uilist.append(urwid.ListBox(self.clients))
479
474
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
480
475
clients),
481
# header=urwid.Divider(),
476
#header=urwid.Divider(),
482
477
header=None,
483
footer=urwid.Divider(
484
div_char=self.divider)))
478
footer=
479
urwid.Divider(div_char=
480
self.divider)))
485
481
if self.log_visible:
486
482
self.uilist.append(self.logbox)
487
483
self.topwidget = urwid.Pile(self.uilist)
488
484
489
485
def log_message(self, message, level=1):
490
486
"""Log message formatted with timestamp"""
491
487
if level < self.log_level:
493
489
timestamp = datetime.datetime.now().isoformat()
494
490
self.log_message_raw("{}: {}".format(timestamp, message),
495
491
level=level)
496
492
497
493
def log_message_raw(self, markup, level=1):
498
494
"""Add a log message to the log buffer."""
499
495
if level < self.log_level:
500
496
return
501
497
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
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]
505
self.logbox.set_focus(len(self.logbox.body.contents)-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]
501
self.logbox.set_focus(len(self.logbox.body.contents),
506
502
coming_from="above")
507
503
self.refresh()
508
504
509
505
def toggle_log_display(self):
510
506
"""Toggle visibility of the log buffer."""
511
507
self.log_visible = not self.log_visible
512
508
self.rebuild()
513
509
self.log_message("Log visibility changed to: {}"
514
510
.format(self.log_visible), level=0)
515
511
516
512
def change_log_display(self):
517
513
"""Change type of log display.
518
514
Currently, this toggles wrapping of text lines."""
524
520
textwidget.set_wrap_mode(self.log_wrap)
525
521
self.log_message("Wrap mode: {}".format(self.log_wrap),
526
522
level=0)
527
528
def find_and_remove_client(self, path, interfaces):
523
524
def find_and_remove_client(self, path, name):
529
525
"""Find a client by its object path and remove it.
530
531
This is connected to the InterfacesRemoved signal from the
526
527
This is connected to the ClientRemoved signal from the
532
528
Mandos server object."""
533
if client_interface not in interfaces:
534
# Not a Mandos client object; ignore
535
return
536
529
try:
537
530
client = self.clients_dict[path]
538
531
except KeyError:
539
532
# not found?
540
self.log_message("Unknown client {!r} removed"
541
.format(path))
533
self.log_message("Unknown client {!r} ({!r}) removed"
534
.format(name, path))
542
535
return
543
536
client.delete()
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
537
538
def add_new_client(self, path):
554
539
client_proxy_object = self.bus.get_object(self.busname, path)
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])),
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),
562
550
path=path)
563
551
564
552
def add_client(self, client, path=None):
565
553
self.clients.append(client)
566
554
if path is None:
568
556
self.clients_dict[path] = client
569
557
self.clients.sort(key=lambda c: c.properties["Name"])
570
558
self.refresh()
571
559
572
560
def remove_client(self, client, path=None):
573
561
self.clients.remove(client)
574
562
if path is None:
575
563
path = client.proxy.object_path
576
564
del self.clients_dict[path]
577
565
self.refresh()
578
566
579
567
def refresh(self):
580
568
"""Redraw the screen"""
581
569
canvas = self.topwidget.render(self.size, focus=True)
582
570
self.screen.draw_screen(self.size, canvas)
583
571
584
572
def run(self):
585
573
"""Start the main loop and exit when it's done."""
586
574
self.bus = dbus.SystemBus()
587
575
mandos_dbus_objc = self.bus.get_object(
588
576
self.busname, "/", follow_name_owner_changes=True)
589
self.mandos_serv = dbus.Interface(
590
mandos_dbus_objc, dbus_interface=server_interface)
577
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
578
dbus_interface
579
= server_interface)
591
580
try:
592
581
mandos_clients = (self.mandos_serv
593
582
.GetAllClientsWithProperties())
594
583
if not mandos_clients:
595
self.log_message_raw(("bold",
596
"Note: Server has no clients."))
584
self.log_message_raw(("bold", "Note: Server has no clients."))
597
585
except dbus.exceptions.DBusException:
598
self.log_message_raw(("bold",
599
"Note: No Mandos server running."))
586
self.log_message_raw(("bold", "Note: No Mandos server running."))
600
587
mandos_clients = dbus.Dictionary()
601
588
602
589
(self.mandos_serv
603
.connect_to_signal("InterfacesRemoved",
590
.connect_to_signal("ClientRemoved",
604
591
self.find_and_remove_client,
605
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
592
dbus_interface=server_interface,
606
593
byte_arrays=True))
607
594
(self.mandos_serv
608
.connect_to_signal("InterfacesAdded",
595
.connect_to_signal("ClientAdded",
609
596
self.add_new_client,
610
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
597
dbus_interface=server_interface,
611
598
byte_arrays=True))
612
599
(self.mandos_serv
613
600
.connect_to_signal("ClientNotFound",
617
604
for path, client in mandos_clients.items():
618
605
client_proxy_object = self.bus.get_object(self.busname,
619
606
path)
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),
607
self.add_client(MandosClientWidget(server_proxy_object
608
=self.mandos_serv,
609
proxy_object
610
=client_proxy_object,
611
properties=client,
612
update_hook
613
=self.refresh,
614
delete_hook
615
=self.remove_client,
616
logger
617
=self.log_message),
627
618
path=path)
628
619
629
620
self.refresh()
630
self._input_callback_tag = (
631
GLib.io_add_watch(
632
GLib.IOChannel.unix_new(sys.stdin.fileno()),
633
GLib.PRIORITY_DEFAULT, GLib.IO_IN,
634
self.process_input))
621
self._input_callback_tag = (gobject.io_add_watch
622
(sys.stdin.fileno(),
623
gobject.IO_IN,
624
self.process_input))
635
625
self.main_loop.run()
636
626
# Main loop has finished, we should close everything now
637
GLib.source_remove(self._input_callback_tag)
638
with warnings.catch_warnings():
639
warnings.simplefilter("ignore", BytesWarning)
640
self.screen.stop()
641
627
gobject.source_remove(self._input_callback_tag)
628
self.screen.stop()
629
642
630
def stop(self):
643
631
self.main_loop.quit()
644
632
645
633
def process_input(self, source, condition):
646
634
keys = self.screen.get_input()
647
translations = {"ctrl n": "down", # Emacs
648
"ctrl p": "up", # Emacs
649
"ctrl v": "page down", # Emacs
650
"meta v": "page up", # Emacs
651
" ": "page down", # less
652
"f": "page down", # less
653
"b": "page up", # less
654
"j": "down", # vi
655
"k": "up", # vi
656
}
635
translations = { "ctrl n": "down", # Emacs
636
"ctrl p": "up", # Emacs
637
"ctrl v": "page down", # Emacs
638
"meta v": "page up", # Emacs
639
" ": "page down", # less
640
"f": "page down", # less
641
"b": "page up", # less
642
"j": "down", # vi
643
"k": "up", # vi
644
}
657
645
for key in keys:
658
646
try:
659
647
key = translations[key]
660
648
except KeyError: # :-)
661
649
pass
662
650
663
651
if key == "q" or key == "Q":
664
652
self.stop()
665
653
break
713
701
else:
714
702
self.log_level = 0
715
703
self.log_message("Verbose mode: On")
716
# elif (key == "end" or key == "meta >" or key == "G"
717
# or key == ">"):
718
# pass # xxx end-of-buffer
719
# elif (key == "home" or key == "meta <" or key == "g"
720
# or key == "<"):
721
# pass # xxx beginning-of-buffer
722
# elif key == "ctrl e" or key == "$":
723
# pass # xxx move-end-of-line
724
# elif key == "ctrl a" or key == "^":
725
# pass # xxx move-beginning-of-line
726
# elif key == "ctrl b" or key == "meta (" or key == "h":
727
# pass # xxx left
728
# elif key == "ctrl f" or key == "meta )" or key == "l":
729
# pass # xxx right
730
# elif key == "a":
731
# pass # scroll up log
732
# elif key == "z":
733
# pass # scroll down log
704
#elif (key == "end" or key == "meta >" or key == "G"
705
# or key == ">"):
706
# pass # xxx end-of-buffer
707
#elif (key == "home" or key == "meta <" or key == "g"
708
# or key == "<"):
709
# pass # xxx beginning-of-buffer
710
#elif key == "ctrl e" or key == "$":
711
# pass # xxx move-end-of-line
712
#elif key == "ctrl a" or key == "^":
713
# pass # xxx move-beginning-of-line
714
#elif key == "ctrl b" or key == "meta (" or key == "h":
715
# pass # xxx left
716
#elif key == "ctrl f" or key == "meta )" or key == "l":
717
# pass # xxx right
718
#elif key == "a":
719
# pass # scroll up log
720
#elif key == "z":
721
# pass # scroll down log
734
722
elif self.topwidget.selectable():
735
723
self.topwidget.keypress(self.size, key)
736
724
self.refresh()
737
725
return True
738
726
739
740
727
ui = UserInterface()
741
728
try:
742
729
ui.run()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0