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