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