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