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