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