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 160
- compare with another revision
- download diff
- download tarball
- view history from revision 160
- Committer: Teddy Hogeborn
- Date: 2008-09-05 07:11:24 UTC
- Revision ID: teddy@fukt.bsnet.se-20080905071124-9dq11jq5rfd6zfxf
* Makefile: Changed to use symbolic instead of octal modes throughout.
(KEYDIR): New variable for the key directory.
(install-server): Bug fix: remove "--parents" from install args.
(install-client): Bug fix: - '' - Also create key directory. Do
not chmod plugin dir. Create custom plugin directory
if not the same as normal plugin directory. Add
"--dir" option to "mandos-keygen". Add note about
running "mandos-keygen --password".
(uninstall-server): Do not depend on the installed server binary,
since this made it impossible to do a purge
after an uninstall.
(purge-client): Shred seckey.txt. Use $(KEYDIR).
* README: Improved wording.
* initramfs-tools-hook: Use a loop to find prefix. Also find keydir.
Remove "${DESTDIR}" from "copy_exec". Do not
try to copy literal "*" if no custom plugins
are found. Copy key files from keydir, not
config dir. Only repair mode on directories
that actually exist. Do not run chmod if
nothing needs repairing.
* plugin-runner.conf: New file.
(KEYDIR): New variable for the key directory.
(install-server): Bug fix: remove "--parents" from install args.
(install-client): Bug fix: - '' - Also create key directory. Do
not chmod plugin dir. Create custom plugin directory
if not the same as normal plugin directory. Add
"--dir" option to "mandos-keygen". Add note about
running "mandos-keygen --password".
(uninstall-server): Do not depend on the installed server binary,
since this made it impossible to do a purge
after an uninstall.
(purge-client): Shred seckey.txt. Use $(KEYDIR).
* README: Improved wording.
* initramfs-tools-hook: Use a loop to find prefix. Also find keydir.
Remove "${DESTDIR}" from "copy_exec". Do not
try to copy literal "*" if no custom plugins
are found. Copy key files from keydir, not
config dir. Only repair mode on directories
that actually exist. Do not run chmod if
nothing needs repairing.
* plugin-runner.conf: New file.
- files added:
- initramfs-tools-hook-conf
- files removed:
- .bzr-builddeb
- debian
- debian/po
- debian/source
- debian/tests
- debian/upstream
- dracut-module
- network-hooks.d
- plugin-helpers
- files renamed:
- plugins.d/mandos-client.c => plugins.d/password-request.c
- plugins.d/mandos-client.xml => plugins.d/password-request.xml
- files modified:
- .bzrignore
added
removed
mandos-monitor
1
#!/usr/bin/python3 -bb
2
# -*- mode: python; coding: utf-8 -*-
3
#
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
13
# the Free Software Foundation, either version 3 of the License, or
14
# (at your option) any later version.
15
#
16
# Mandos is distributed in the hope that it will be useful, but
17
# WITHOUT ANY WARRANTY; without even the implied warranty of
18
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19
# GNU General Public License for more details.
20
#
21
# 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
#
24
# Contact the authors at <mandos@recompile.se>.
25
#
26
27
from __future__ import (division, absolute_import, print_function,
28
unicode_literals)
29
try:
30
from future_builtins import *
31
except ImportError:
32
pass
33
34
import sys
35
import os
36
import warnings
37
import datetime
38
39
import urwid.curses_display
40
import urwid
41
42
from dbus.mainloop.glib import DBusGMainLoop
43
from gi.repository import GLib
44
45
import dbus
46
47
import locale
48
49
import logging
50
51
if sys.version_info.major == 2:
52
str = unicode
53
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
locale.setlocale(locale.LC_ALL, '')
61
62
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
63
64
# Some useful constants
65
domain = 'se.recompile'
66
server_interface = domain + '.Mandos'
67
client_interface = domain + '.Mandos.Client'
68
version = "1.8.9"
69
70
try:
71
dbus.OBJECT_MANAGER_IFACE
72
except AttributeError:
73
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
74
75
76
def isoformat_to_datetime(iso):
77
"Parse an ISO 8601 date string to a datetime.datetime()"
78
if not iso:
79
return None
80
d, t = iso.split("T", 1)
81
year, month, day = d.split("-", 2)
82
hour, minute, second = t.split(":", 2)
83
second, fraction = divmod(float(second), 1)
84
return datetime.datetime(int(year),
85
int(month),
86
int(day),
87
int(hour),
88
int(minute),
89
int(second), # Whole seconds
90
int(fraction*1000000)) # Microseconds
91
92
93
class MandosClientPropertyCache(object):
94
"""This wraps a Mandos Client D-Bus proxy object, caches the
95
properties and calls a hook function when any of them are
96
changed.
97
"""
98
def __init__(self, proxy_object=None, properties=None, **kwargs):
99
self.proxy = proxy_object # Mandos Client proxy object
100
self.properties = dict() if properties is None else properties
101
self.property_changed_match = (
102
self.proxy.connect_to_signal("PropertiesChanged",
103
self.properties_changed,
104
dbus.PROPERTIES_IFACE,
105
byte_arrays=True))
106
107
if properties is None:
108
self.properties.update(self.proxy.GetAll(
109
client_interface,
110
dbus_interface=dbus.PROPERTIES_IFACE))
111
112
super(MandosClientPropertyCache, self).__init__(**kwargs)
113
114
def properties_changed(self, interface, properties, invalidated):
115
"""This is called whenever we get a PropertiesChanged signal
116
It updates the changed properties in the "properties" dict.
117
"""
118
# Update properties dict with new value
119
if interface == client_interface:
120
self.properties.update(properties)
121
122
def delete(self):
123
self.property_changed_match.remove()
124
125
126
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
127
"""A Mandos Client which is visible on the screen.
128
"""
129
130
def __init__(self, server_proxy_object=None, update_hook=None,
131
delete_hook=None, **kwargs):
132
# Called on update
133
self.update_hook = update_hook
134
# Called on delete
135
self.delete_hook = delete_hook
136
# Mandos Server proxy object
137
self.server_proxy_object = server_proxy_object
138
139
self._update_timer_callback_tag = None
140
141
# The widget shown normally
142
self._text_widget = urwid.Text("")
143
# The widget shown when we have focus
144
self._focus_text_widget = urwid.Text("")
145
super(MandosClientWidget, self).__init__(**kwargs)
146
self.update()
147
self.opened = False
148
149
self.match_objects = (
150
self.proxy.connect_to_signal("CheckerCompleted",
151
self.checker_completed,
152
client_interface,
153
byte_arrays=True),
154
self.proxy.connect_to_signal("CheckerStarted",
155
self.checker_started,
156
client_interface,
157
byte_arrays=True),
158
self.proxy.connect_to_signal("GotSecret",
159
self.got_secret,
160
client_interface,
161
byte_arrays=True),
162
self.proxy.connect_to_signal("NeedApproval",
163
self.need_approval,
164
client_interface,
165
byte_arrays=True),
166
self.proxy.connect_to_signal("Rejected",
167
self.rejected,
168
client_interface,
169
byte_arrays=True))
170
log.debug('Created client %s', self.properties["Name"])
171
172
def using_timer(self, flag):
173
"""Call this method with True or False when timer should be
174
activated or deactivated.
175
"""
176
if flag and self._update_timer_callback_tag is None:
177
# 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)))
181
elif not (flag or self._update_timer_callback_tag is None):
182
GLib.source_remove(self._update_timer_callback_tag)
183
self._update_timer_callback_tag = None
184
185
def checker_completed(self, exitstatus, condition, command):
186
if exitstatus == 0:
187
log.debug('Checker for client %s (command "%s")'
188
' succeeded', self.properties["Name"], command)
189
self.update()
190
return
191
# Checker failed
192
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))
196
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))
200
self.update()
201
202
def checker_started(self, command):
203
"""Server signals that a checker started."""
204
log.debug('Client %s started checker "%s"',
205
self.properties["Name"], command)
206
207
def got_secret(self):
208
log.info("Client %s received its secret",
209
self.properties["Name"])
210
211
def need_approval(self, timeout, default):
212
if not default:
213
message = "Client %s needs approval within %f seconds"
214
else:
215
message = "Client %s will get its secret in %f seconds"
216
log.info(message, self.properties["Name"], timeout/1000)
217
218
def rejected(self, reason):
219
log.info("Client %s was rejected; reason: %s",
220
self.properties["Name"], reason)
221
222
def selectable(self):
223
"""Make this a "selectable" widget.
224
This overrides the method from urwid.FlowWidget."""
225
return True
226
227
def rows(self, maxcolrow, focus=False):
228
"""How many rows this widget will occupy might depend on
229
whether we have focus or not.
230
This overrides the method from urwid.FlowWidget"""
231
return self.current_widget(focus).rows(maxcolrow, focus=focus)
232
233
def current_widget(self, focus=False):
234
if focus or self.opened:
235
return self._focus_widget
236
return self._widget
237
238
def update(self):
239
"Called when what is visible on the screen should be updated."
240
# 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
249
# Rebuild focus and non-focus widgets using current properties
250
251
# Base part of a client. Name!
252
base = '{name}: '.format(name=self.properties["Name"])
253
if not self.properties["Enabled"]:
254
message = "DISABLED"
255
self.using_timer(False)
256
elif self.properties["ApprovalPending"]:
257
timeout = datetime.timedelta(
258
milliseconds=self.properties["ApprovalDelay"])
259
last_approval_request = isoformat_to_datetime(
260
self.properties["LastApprovalRequest"])
261
if last_approval_request is not None:
262
timer = max(timeout - (datetime.datetime.utcnow()
263
- last_approval_request),
264
datetime.timedelta())
265
else:
266
timer = datetime.timedelta()
267
if self.properties["ApprovedByDefault"]:
268
message = "Approval in {}. (d)eny?"
269
else:
270
message = "Denial in {}. (a)pprove?"
271
message = message.format(str(timer).rsplit(".", 1)[0])
272
self.using_timer(True)
273
elif self.properties["LastCheckerStatus"] != 0:
274
# When checker has failed, show timer until client expires
275
expires = self.properties["Expires"]
276
if expires == "":
277
timer = datetime.timedelta(0)
278
else:
279
expires = (datetime.datetime.strptime
280
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
281
timer = max(expires - datetime.datetime.utcnow(),
282
datetime.timedelta())
283
message = ('A checker has failed! Time until client'
284
' gets disabled: {}'
285
.format(str(timer).rsplit(".", 1)[0]))
286
self.using_timer(True)
287
else:
288
message = "enabled"
289
self.using_timer(False)
290
self._text = "{}{}".format(base, message)
291
292
if not urwid.supports_unicode():
293
self._text = self._text.encode("ascii", "replace")
294
textlist = [("normal", self._text)]
295
self._text_widget.set_text(textlist)
296
self._focus_text_widget.set_text([(with_standout[text[0]],
297
text[1])
298
if isinstance(text, tuple)
299
else text
300
for text in textlist])
301
self._widget = self._text_widget
302
self._focus_widget = urwid.AttrWrap(self._focus_text_widget,
303
"standout")
304
# Run update hook, if any
305
if self.update_hook is not None:
306
self.update_hook()
307
308
def update_timer(self):
309
"""called by GLib. Will indefinitely loop until
310
GLib.source_remove() on tag is called
311
"""
312
self.update()
313
return True # Keep calling this
314
315
def delete(self, **kwargs):
316
if self._update_timer_callback_tag is not None:
317
GLib.source_remove(self._update_timer_callback_tag)
318
self._update_timer_callback_tag = None
319
for match in self.match_objects:
320
match.remove()
321
self.match_objects = ()
322
if self.delete_hook is not None:
323
self.delete_hook(self)
324
return super(MandosClientWidget, self).delete(**kwargs)
325
326
def render(self, maxcolrow, focus=False):
327
"""Render differently if we have focus.
328
This overrides the method from urwid.FlowWidget"""
329
return self.current_widget(focus).render(maxcolrow,
330
focus=focus)
331
332
def keypress(self, maxcolrow, key):
333
"""Handle keys.
334
This overrides the method from urwid.FlowWidget"""
335
if key == "+":
336
self.proxy.Set(client_interface, "Enabled",
337
dbus.Boolean(True), ignore_reply=True,
338
dbus_interface=dbus.PROPERTIES_IFACE)
339
elif key == "-":
340
self.proxy.Set(client_interface, "Enabled", False,
341
ignore_reply=True,
342
dbus_interface=dbus.PROPERTIES_IFACE)
343
elif key == "a":
344
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
345
dbus_interface=client_interface,
346
ignore_reply=True)
347
elif key == "d":
348
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
349
dbus_interface=client_interface,
350
ignore_reply=True)
351
elif key == "R" or key == "_" or key == "ctrl k":
352
self.server_proxy_object.RemoveClient(self.proxy
353
.object_path,
354
ignore_reply=True)
355
elif key == "s":
356
self.proxy.Set(client_interface, "CheckerRunning",
357
dbus.Boolean(True), ignore_reply=True,
358
dbus_interface=dbus.PROPERTIES_IFACE)
359
elif key == "S":
360
self.proxy.Set(client_interface, "CheckerRunning",
361
dbus.Boolean(False), ignore_reply=True,
362
dbus_interface=dbus.PROPERTIES_IFACE)
363
elif key == "C":
364
self.proxy.CheckedOK(dbus_interface=client_interface,
365
ignore_reply=True)
366
# xxx
367
# elif key == "p" or key == "=":
368
# self.proxy.pause()
369
# elif key == "u" or key == ":":
370
# self.proxy.unpause()
371
# elif key == "RET":
372
# self.open()
373
else:
374
return key
375
376
def properties_changed(self, interface, properties, invalidated):
377
"""Call self.update() if any properties changed.
378
This overrides the method from MandosClientPropertyCache"""
379
old_values = {key: self.properties.get(key)
380
for key in properties.keys()}
381
super(MandosClientWidget, self).properties_changed(
382
interface, properties, invalidated)
383
if any(old_values[key] != self.properties.get(key)
384
for key in old_values):
385
self.update()
386
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
class ConstrainedListBox(urwid.ListBox):
399
"""Like a normal urwid.ListBox, but will consume all "up" or
400
"down" key presses, thus not allowing any containing widgets to
401
use them as an excuse to shift focus away from this widget.
402
"""
403
def keypress(self, *args, **kwargs):
404
ret = (super(ConstrainedListBox, self)
405
.keypress(*args, **kwargs))
406
if ret in ("up", "down"):
407
return
408
return ret
409
410
411
class UserInterface(object):
412
"""This is the entire user interface - the whole screen
413
with boxes, lists of client widgets, etc.
414
"""
415
def __init__(self, max_log_length=1000):
416
DBusGMainLoop(set_as_default=True)
417
418
self.screen = urwid.curses_display.Screen()
419
420
self.screen.register_palette((
421
("normal",
422
"default", "default", None),
423
("bold",
424
"bold", "default", "bold"),
425
("underline-blink",
426
"underline,blink", "default", "underline,blink"),
427
("standout",
428
"standout", "default", "standout"),
429
("bold-underline-blink",
430
"bold,underline,blink", "default",
431
"bold,underline,blink"),
432
("bold-standout",
433
"bold,standout", "default", "bold,standout"),
434
("underline-blink-standout",
435
"underline,blink,standout", "default",
436
"underline,blink,standout"),
437
("bold-underline-blink-standout",
438
"bold,underline,blink,standout", "default",
439
"bold,underline,blink,standout"),
440
))
441
442
if urwid.supports_unicode():
443
self.divider = "─" # \u2500
444
else:
445
self.divider = "_" # \u005f
446
447
self.screen.start()
448
449
self.size = self.screen.get_cols_rows()
450
451
self.clients = urwid.SimpleListWalker([])
452
self.clients_dict = {}
453
454
# We will add Text widgets to this list
455
self.log = urwid.SimpleListWalker([])
456
self.max_log_length = max_log_length
457
458
# We keep a reference to the log widget so we can remove it
459
# from the ListWalker without it getting destroyed
460
self.logbox = ConstrainedListBox(self.log)
461
462
# This keeps track of whether self.uilist currently has
463
# self.logbox in it or not
464
self.log_visible = True
465
self.log_wrap = "any"
466
467
self.loghandler = UILogHandler(self)
468
469
self.rebuild()
470
self.add_log_line(("bold",
471
"Mandos Monitor version " + version))
472
self.add_log_line(("bold", "q: Quit ?: Help"))
473
474
self.busname = domain + '.Mandos'
475
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
481
def rebuild(self):
482
"""This rebuilds the User Interface.
483
Call this when the widget layout needs to change"""
484
self.uilist = []
485
# self.uilist.append(urwid.ListBox(self.clients))
486
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
487
clients),
488
# header=urwid.Divider(),
489
header=None,
490
footer=urwid.Divider(
491
div_char=self.divider)))
492
if self.log_visible:
493
self.uilist.append(self.logbox)
494
self.topwidget = urwid.Pile(self.uilist)
495
496
def add_log_line(self, markup):
497
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
coming_from="above")
503
self.refresh()
504
505
def toggle_log_display(self):
506
"""Toggle visibility of the log buffer."""
507
self.log_visible = not self.log_visible
508
self.rebuild()
509
log.debug("Log visibility changed to: %s", self.log_visible)
510
511
def change_log_display(self):
512
"""Change type of log display.
513
Currently, this toggles wrapping of text lines."""
514
if self.log_wrap == "clip":
515
self.log_wrap = "any"
516
else:
517
self.log_wrap = "clip"
518
for textwidget in self.log:
519
textwidget.set_wrap_mode(self.log_wrap)
520
log.debug("Wrap mode: %s", self.log_wrap)
521
522
def find_and_remove_client(self, path, interfaces):
523
"""Find a client by its object path and remove it.
524
525
This is connected to the InterfacesRemoved signal from the
526
Mandos server object."""
527
if client_interface not in interfaces:
528
# Not a Mandos client object; ignore
529
return
530
try:
531
client = self.clients_dict[path]
532
except KeyError:
533
# not found?
534
log.warning("Unknown client %s removed", path)
535
return
536
client.delete()
537
538
def add_new_client(self, path, ifs_and_props):
539
"""Find a client by its object path and remove it.
540
541
This is connected to the InterfacesAdded signal from the
542
Mandos server object.
543
"""
544
if client_interface not in ifs_and_props:
545
# Not a Mandos client object; ignore
546
return
547
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])),
554
path=path)
555
556
def add_client(self, client, path=None):
557
self.clients.append(client)
558
if path is None:
559
path = client.proxy.object_path
560
self.clients_dict[path] = client
561
self.clients.sort(key=lambda c: c.properties["Name"])
562
self.refresh()
563
564
def remove_client(self, client, path=None):
565
self.clients.remove(client)
566
if path is None:
567
path = client.proxy.object_path
568
del self.clients_dict[path]
569
self.refresh()
570
571
def refresh(self):
572
"""Redraw the screen"""
573
canvas = self.topwidget.render(self.size, focus=True)
574
self.screen.draw_screen(self.size, canvas)
575
576
def run(self):
577
"""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
self.bus = dbus.SystemBus()
584
mandos_dbus_objc = self.bus.get_object(
585
self.busname, "/", follow_name_owner_changes=True)
586
self.mandos_serv = dbus.Interface(
587
mandos_dbus_objc, dbus_interface=server_interface)
588
try:
589
mandos_clients = (self.mandos_serv
590
.GetAllClientsWithProperties())
591
if not mandos_clients:
592
log.warning("Note: Server has no clients.")
593
except dbus.exceptions.DBusException:
594
log.warning("Note: No Mandos server running.")
595
mandos_clients = dbus.Dictionary()
596
597
(self.mandos_serv
598
.connect_to_signal("InterfacesRemoved",
599
self.find_and_remove_client,
600
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
601
byte_arrays=True))
602
(self.mandos_serv
603
.connect_to_signal("InterfacesAdded",
604
self.add_new_client,
605
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
606
byte_arrays=True))
607
(self.mandos_serv
608
.connect_to_signal("ClientNotFound",
609
self.client_not_found,
610
dbus_interface=server_interface,
611
byte_arrays=True))
612
for path, client in mandos_clients.items():
613
client_proxy_object = self.bus.get_object(self.busname,
614
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),
621
path=path)
622
623
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)))
629
self.main_loop.run()
630
# Main loop has finished, we should close everything now
631
GLib.source_remove(self._input_callback_tag)
632
with warnings.catch_warnings():
633
warnings.simplefilter("ignore", BytesWarning)
634
self.screen.stop()
635
636
def stop(self):
637
self.main_loop.quit()
638
log.removeHandler(self.loghandler)
639
log.propagate = self.orig_log_propagate
640
641
def process_input(self, source, condition):
642
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
}
653
for key in keys:
654
try:
655
key = translations[key]
656
except KeyError: # :-)
657
pass
658
659
if key == "q" or key == "Q":
660
self.stop()
661
break
662
elif key == "window resize":
663
self.size = self.screen.get_cols_rows()
664
self.refresh()
665
elif key == "ctrl l":
666
self.screen.clear()
667
self.refresh()
668
elif key == "l" or key == "D":
669
self.toggle_log_display()
670
self.refresh()
671
elif key == "w" or key == "i":
672
self.change_log_display()
673
self.refresh()
674
elif key == "?" or key == "f1" or key == "esc":
675
if not self.log_visible:
676
self.log_visible = True
677
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
))))
697
self.refresh()
698
elif key == "tab":
699
if self.topwidget.get_focus() is self.logbox:
700
self.topwidget.set_focus(0)
701
else:
702
self.topwidget.set_focus(self.logbox)
703
self.refresh()
704
elif key == "v":
705
if log.level < logging.INFO:
706
log.setLevel(logging.INFO)
707
log.info("Verbose mode: Off")
708
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
729
elif self.topwidget.selectable():
730
self.topwidget.keypress(self.size, key)
731
self.refresh()
732
return True
733
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
ui = UserInterface()
749
try:
750
ui.run()
751
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()
759
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0