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 749
- compare with another revision
- download diff
- download tarball
- view history from revision 749
- Committer: Teddy Hogeborn
- Date: 2015-05-23 12:07:07 UTC
- Revision ID: teddy@recompile.se-20150523120707-t5fq0brh2kxkvw8g
mandos: Some more minor changes to prepare for Python 3.
added
removed
mandos-monitor
1
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-2017 Teddy Hogeborn
7
# Copyright © 2009-2017 Björn Påhlsson
8
#
5
#
6
# Copyright © 2009-2014 Teddy Hogeborn
7
# Copyright © 2009-2014 Björn Påhlsson
8
#
9
9
# This program is free software: you can redistribute it and/or modify
10
10
# it under the terms of the GNU General Public License as published by
11
11
# the Free Software Foundation, either version 3 of the License, or
15
15
# but WITHOUT ANY WARRANTY; without even the implied warranty of
16
16
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17
17
# GNU General Public License for more details.
18
#
18
#
19
19
# You should have received a copy of the GNU General Public License
20
20
# along with this program. If not, see
21
21
# <http://www.gnu.org/licenses/>.
22
#
22
#
23
23
# Contact the authors at <mandos@recompile.se>.
24
#
24
#
25
25
26
26
from __future__ import (division, absolute_import, print_function,
27
27
unicode_literals)
39
39
import urwid
40
40
41
41
from dbus.mainloop.glib import DBusGMainLoop
42
from gi.repository import GLib
42
try:
43
import gobject
44
except ImportError:
45
from gi.repository import GObject as gobject
43
46
44
47
import dbus
45
48
46
49
import locale
47
50
48
import logging
49
50
51
if sys.version_info.major == 2:
51
52
str = unicode
52
53
53
54
locale.setlocale(locale.LC_ALL, '')
54
55
56
import logging
55
57
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
56
58
57
59
# Some useful constants
58
60
domain = 'se.recompile'
59
61
server_interface = domain + '.Mandos'
60
62
client_interface = domain + '.Mandos.Client'
61
version = "1.7.14"
62
63
try:
64
dbus.OBJECT_MANAGER_IFACE
65
except AttributeError:
66
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
67
63
version = "1.6.9"
68
64
69
65
def isoformat_to_datetime(iso):
70
66
"Parse an ISO 8601 date string to a datetime.datetime()"
79
75
int(day),
80
76
int(hour),
81
77
int(minute),
82
int(second), # Whole seconds
83
int(fraction*1000000)) # Microseconds
84
78
int(second), # Whole seconds
79
int(fraction*1000000)) # Microseconds
85
80
86
81
class MandosClientPropertyCache(object):
87
82
"""This wraps a Mandos Client D-Bus proxy object, caches the
89
84
changed.
90
85
"""
91
86
def __init__(self, proxy_object=None, properties=None, **kwargs):
92
self.proxy = proxy_object # Mandos Client proxy object
87
self.proxy = proxy_object # Mandos Client proxy object
93
88
self.properties = dict() if properties is None else properties
94
89
self.property_changed_match = (
95
90
self.proxy.connect_to_signal("PropertiesChanged",
96
91
self.properties_changed,
97
92
dbus.PROPERTIES_IFACE,
98
93
byte_arrays=True))
99
94
100
95
if properties is None:
101
self.properties.update(self.proxy.GetAll(
102
client_interface,
103
dbus_interface=dbus.PROPERTIES_IFACE))
104
96
self.properties.update(
97
self.proxy.GetAll(client_interface,
98
dbus_interface
99
= dbus.PROPERTIES_IFACE))
100
105
101
super(MandosClientPropertyCache, self).__init__(**kwargs)
106
102
107
103
def properties_changed(self, interface, properties, invalidated):
108
104
"""This is called whenever we get a PropertiesChanged signal
109
105
It updates the changed properties in the "properties" dict.
110
106
"""
111
107
# Update properties dict with new value
112
if interface == client_interface:
113
self.properties.update(properties)
114
108
self.properties.update(properties)
109
115
110
def delete(self):
116
111
self.property_changed_match.remove()
117
112
119
114
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
120
115
"""A Mandos Client which is visible on the screen.
121
116
"""
122
117
123
118
def __init__(self, server_proxy_object=None, update_hook=None,
124
119
delete_hook=None, logger=None, **kwargs):
125
120
# Called on update
130
125
self.server_proxy_object = server_proxy_object
131
126
# Logger
132
127
self.logger = logger
133
128
134
129
self._update_timer_callback_tag = None
135
130
136
131
# The widget shown normally
137
132
self._text_widget = urwid.Text("")
138
133
# The widget shown when we have focus
140
135
super(MandosClientWidget, self).__init__(**kwargs)
141
136
self.update()
142
137
self.opened = False
143
138
144
139
self.match_objects = (
145
140
self.proxy.connect_to_signal("CheckerCompleted",
146
141
self.checker_completed,
164
159
byte_arrays=True))
165
160
self.logger('Created client {}'
166
161
.format(self.properties["Name"]), level=0)
167
162
168
163
def using_timer(self, flag):
169
164
"""Call this method with True or False when timer should be
170
165
activated or deactivated.
171
166
"""
172
167
if flag and self._update_timer_callback_tag is None:
173
168
# Will update the shown timer value every second
174
self._update_timer_callback_tag = (GLib.timeout_add
169
self._update_timer_callback_tag = (gobject.timeout_add
175
170
(1000,
176
171
self.update_timer))
177
172
elif not (flag or self._update_timer_callback_tag is None):
178
GLib.source_remove(self._update_timer_callback_tag)
173
gobject.source_remove(self._update_timer_callback_tag)
179
174
self._update_timer_callback_tag = None
180
175
181
176
def checker_completed(self, exitstatus, condition, command):
182
177
if exitstatus == 0:
183
178
self.logger('Checker for client {} (command "{}")'
196
191
' killed by signal {}'
197
192
.format(self.properties["Name"], command,
198
193
os.WTERMSIG(condition)))
194
elif os.WCOREDUMP(condition):
195
self.logger('Checker for client {} (command "{}") dumped'
196
' core'.format(self.properties["Name"],
197
command))
198
else:
199
self.logger('Checker for client {} completed'
200
' mysteriously'
201
.format(self.properties["Name"]))
199
202
self.update()
200
203
201
204
def checker_started(self, command):
202
205
"""Server signals that a checker started."""
203
206
self.logger('Client {} started checker "{}"'
204
207
.format(self.properties["Name"],
205
208
command), level=0)
206
209
207
210
def got_secret(self):
208
211
self.logger('Client {} received its secret'
209
212
.format(self.properties["Name"]))
210
213
211
214
def need_approval(self, timeout, default):
212
215
if not default:
213
216
message = 'Client {} needs approval within {} seconds'
215
218
message = 'Client {} will get its secret in {} seconds'
216
219
self.logger(message.format(self.properties["Name"],
217
220
timeout/1000))
218
221
219
222
def rejected(self, reason):
220
223
self.logger('Client {} was rejected; reason: {}'
221
224
.format(self.properties["Name"], reason))
222
225
223
226
def selectable(self):
224
227
"""Make this a "selectable" widget.
225
228
This overrides the method from urwid.FlowWidget."""
226
229
return True
227
230
228
231
def rows(self, maxcolrow, focus=False):
229
232
"""How many rows this widget will occupy might depend on
230
233
whether we have focus or not.
231
234
This overrides the method from urwid.FlowWidget"""
232
235
return self.current_widget(focus).rows(maxcolrow, focus=focus)
233
236
234
237
def current_widget(self, focus=False):
235
238
if focus or self.opened:
236
239
return self._focus_widget
237
240
return self._widget
238
241
239
242
def update(self):
240
243
"Called when what is visible on the screen should be updated."
241
244
# How to add standout mode to a style
242
with_standout = {"normal": "standout",
243
"bold": "bold-standout",
244
"underline-blink":
245
"underline-blink-standout",
246
"bold-underline-blink":
247
"bold-underline-blink-standout",
248
}
249
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
250
253
# Rebuild focus and non-focus widgets using current properties
251
254
252
255
# Base part of a client. Name!
253
256
base = '{name}: '.format(name=self.properties["Name"])
254
257
if not self.properties["Enabled"]:
255
258
message = "DISABLED"
256
259
self.using_timer(False)
257
260
elif self.properties["ApprovalPending"]:
258
timeout = datetime.timedelta(
259
milliseconds=self.properties["ApprovalDelay"])
261
timeout = datetime.timedelta(milliseconds
262
= self.properties
263
["ApprovalDelay"])
260
264
last_approval_request = isoformat_to_datetime(
261
265
self.properties["LastApprovalRequest"])
262
266
if last_approval_request is not None:
289
293
message = "enabled"
290
294
self.using_timer(False)
291
295
self._text = "{}{}".format(base, message)
292
296
293
297
if not urwid.supports_unicode():
294
298
self._text = self._text.encode("ascii", "replace")
295
299
textlist = [("normal", self._text)]
305
309
# Run update hook, if any
306
310
if self.update_hook is not None:
307
311
self.update_hook()
308
312
309
313
def update_timer(self):
310
"""called by GLib. Will indefinitely loop until
311
GLib.source_remove() on tag is called
312
"""
314
"""called by gobject. Will indefinitely loop until
315
gobject.source_remove() on tag is called"""
313
316
self.update()
314
317
return True # Keep calling this
315
318
316
319
def delete(self, **kwargs):
317
320
if self._update_timer_callback_tag is not None:
318
GLib.source_remove(self._update_timer_callback_tag)
321
gobject.source_remove(self._update_timer_callback_tag)
319
322
self._update_timer_callback_tag = None
320
323
for match in self.match_objects:
321
324
match.remove()
323
326
if self.delete_hook is not None:
324
327
self.delete_hook(self)
325
328
return super(MandosClientWidget, self).delete(**kwargs)
326
329
327
330
def render(self, maxcolrow, focus=False):
328
331
"""Render differently if we have focus.
329
332
This overrides the method from urwid.FlowWidget"""
330
333
return self.current_widget(focus).render(maxcolrow,
331
334
focus=focus)
332
335
333
336
def keypress(self, maxcolrow, key):
334
337
"""Handle keys.
335
338
This overrides the method from urwid.FlowWidget"""
336
339
if key == "+":
337
self.proxy.Set(client_interface, "Enabled",
338
dbus.Boolean(True), ignore_reply=True,
339
dbus_interface=dbus.PROPERTIES_IFACE)
340
self.proxy.Enable(dbus_interface = client_interface,
341
ignore_reply=True)
340
342
elif key == "-":
341
self.proxy.Set(client_interface, "Enabled", False,
342
ignore_reply=True,
343
dbus_interface=dbus.PROPERTIES_IFACE)
343
self.proxy.Disable(dbus_interface = client_interface,
344
ignore_reply=True)
344
345
elif key == "a":
345
346
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
346
dbus_interface=client_interface,
347
dbus_interface = client_interface,
347
348
ignore_reply=True)
348
349
elif key == "d":
349
350
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
350
dbus_interface=client_interface,
351
dbus_interface = client_interface,
351
352
ignore_reply=True)
352
353
elif key == "R" or key == "_" or key == "ctrl k":
353
354
self.server_proxy_object.RemoveClient(self.proxy
354
355
.object_path,
355
356
ignore_reply=True)
356
357
elif key == "s":
357
self.proxy.Set(client_interface, "CheckerRunning",
358
dbus.Boolean(True), ignore_reply=True,
359
dbus_interface=dbus.PROPERTIES_IFACE)
358
self.proxy.StartChecker(dbus_interface = client_interface,
359
ignore_reply=True)
360
360
elif key == "S":
361
self.proxy.Set(client_interface, "CheckerRunning",
362
dbus.Boolean(False), ignore_reply=True,
363
dbus_interface=dbus.PROPERTIES_IFACE)
361
self.proxy.StopChecker(dbus_interface = client_interface,
362
ignore_reply=True)
364
363
elif key == "C":
365
self.proxy.CheckedOK(dbus_interface=client_interface,
364
self.proxy.CheckedOK(dbus_interface = client_interface,
366
365
ignore_reply=True)
367
366
# xxx
368
367
# elif key == "p" or key == "=":
373
372
# self.open()
374
373
else:
375
374
return key
376
375
377
376
def properties_changed(self, interface, properties, invalidated):
378
377
"""Call self.update() if any properties changed.
379
378
This overrides the method from MandosClientPropertyCache"""
380
old_values = {key: self.properties.get(key)
381
for key in properties.keys()}
379
old_values = { key: self.properties.get(key)
380
for key in properties.keys() }
382
381
super(MandosClientWidget, self).properties_changed(
383
382
interface, properties, invalidated)
384
383
if any(old_values[key] != self.properties.get(key)
392
391
use them as an excuse to shift focus away from this widget.
393
392
"""
394
393
def keypress(self, *args, **kwargs):
395
ret = (super(ConstrainedListBox, self)
396
.keypress(*args, **kwargs))
394
ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
397
395
if ret in ("up", "down"):
398
396
return
399
397
return ret
405
403
"""
406
404
def __init__(self, max_log_length=1000, log_level=1):
407
405
DBusGMainLoop(set_as_default=True)
408
406
409
407
self.screen = urwid.curses_display.Screen()
410
408
411
409
self.screen.register_palette((
412
410
("normal",
413
411
"default", "default", None),
418
416
("standout",
419
417
"standout", "default", "standout"),
420
418
("bold-underline-blink",
421
"bold,underline,blink", "default",
422
"bold,underline,blink"),
419
"bold,underline,blink", "default", "bold,underline,blink"),
423
420
("bold-standout",
424
421
"bold,standout", "default", "bold,standout"),
425
422
("underline-blink-standout",
429
426
"bold,underline,blink,standout", "default",
430
427
"bold,underline,blink,standout"),
431
428
))
432
429
433
430
if urwid.supports_unicode():
434
self.divider = "─" # \u2500
431
self.divider = "─" # \u2500
432
#self.divider = "━" # \u2501
435
433
else:
436
self.divider = "_" # \u005f
437
434
#self.divider = "-" # \u002d
435
self.divider = "_" # \u005f
436
438
437
self.screen.start()
439
438
440
439
self.size = self.screen.get_cols_rows()
441
440
442
441
self.clients = urwid.SimpleListWalker([])
443
442
self.clients_dict = {}
444
443
445
444
# We will add Text widgets to this list
446
445
self.log = []
447
446
self.max_log_length = max_log_length
448
447
449
448
self.log_level = log_level
450
449
451
450
# We keep a reference to the log widget so we can remove it
452
451
# from the ListWalker without it getting destroyed
453
452
self.logbox = ConstrainedListBox(self.log)
454
453
455
454
# This keeps track of whether self.uilist currently has
456
455
# self.logbox in it or not
457
456
self.log_visible = True
458
457
self.log_wrap = "any"
459
458
460
459
self.rebuild()
461
460
self.log_message_raw(("bold",
462
461
"Mandos Monitor version " + version))
463
462
self.log_message_raw(("bold",
464
463
"q: Quit ?: Help"))
465
464
466
465
self.busname = domain + '.Mandos'
467
self.main_loop = GLib.MainLoop()
468
466
self.main_loop = gobject.MainLoop()
467
469
468
def client_not_found(self, fingerprint, address):
470
469
self.log_message("Client with address {} and fingerprint {}"
471
470
" could not be found"
472
471
.format(address, fingerprint))
473
472
474
473
def rebuild(self):
475
474
"""This rebuilds the User Interface.
476
475
Call this when the widget layout needs to change"""
477
476
self.uilist = []
478
# self.uilist.append(urwid.ListBox(self.clients))
477
#self.uilist.append(urwid.ListBox(self.clients))
479
478
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
480
479
clients),
481
# header=urwid.Divider(),
480
#header=urwid.Divider(),
482
481
header=None,
483
footer=urwid.Divider(
484
div_char=self.divider)))
482
footer=
483
urwid.Divider(div_char=
484
self.divider)))
485
485
if self.log_visible:
486
486
self.uilist.append(self.logbox)
487
487
self.topwidget = urwid.Pile(self.uilist)
488
488
489
489
def log_message(self, message, level=1):
490
490
"""Log message formatted with timestamp"""
491
491
if level < self.log_level:
493
493
timestamp = datetime.datetime.now().isoformat()
494
494
self.log_message_raw("{}: {}".format(timestamp, message),
495
495
level=level)
496
496
497
497
def log_message_raw(self, markup, level=1):
498
498
"""Add a log message to the log buffer."""
499
499
if level < self.log_level:
500
500
return
501
501
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
502
if self.max_log_length:
503
if len(self.log) > self.max_log_length:
504
del self.log[0:len(self.log)-self.max_log_length-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
505
self.logbox.set_focus(len(self.logbox.body.contents),
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
513
self.log_message("Log visibility changed to: {}"
514
514
.format(self.log_visible), level=0)
515
515
516
516
def change_log_display(self):
517
517
"""Change type of log display.
518
518
Currently, this toggles wrapping of text lines."""
524
524
textwidget.set_wrap_mode(self.log_wrap)
525
525
self.log_message("Wrap mode: {}".format(self.log_wrap),
526
526
level=0)
527
528
def find_and_remove_client(self, path, interfaces):
527
528
def find_and_remove_client(self, path, name):
529
529
"""Find a client by its object path and remove it.
530
531
This is connected to the InterfacesRemoved signal from the
530
531
This is connected to the ClientRemoved signal from the
532
532
Mandos server object."""
533
if client_interface not in interfaces:
534
# Not a Mandos client object; ignore
535
return
536
533
try:
537
534
client = self.clients_dict[path]
538
535
except KeyError:
539
536
# not found?
540
self.log_message("Unknown client {!r} removed"
541
.format(path))
537
self.log_message("Unknown client {!r} ({!r}) removed"
538
.format(name, path))
542
539
return
543
540
client.delete()
544
545
def add_new_client(self, path, ifs_and_props):
546
"""Find a client by its object path and remove it.
547
548
This is connected to the InterfacesAdded signal from the
549
Mandos server object.
550
"""
551
if client_interface not in ifs_and_props:
552
# Not a Mandos client object; ignore
553
return
541
542
def add_new_client(self, path):
554
543
client_proxy_object = self.bus.get_object(self.busname, path)
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
logger=self.log_message,
561
properties=dict(ifs_and_props[client_interface])),
544
self.add_client(MandosClientWidget(server_proxy_object
545
=self.mandos_serv,
546
proxy_object
547
=client_proxy_object,
548
update_hook
549
=self.refresh,
550
delete_hook
551
=self.remove_client,
552
logger
553
=self.log_message),
562
554
path=path)
563
555
564
556
def add_client(self, client, path=None):
565
557
self.clients.append(client)
566
558
if path is None:
568
560
self.clients_dict[path] = client
569
561
self.clients.sort(key=lambda c: c.properties["Name"])
570
562
self.refresh()
571
563
572
564
def remove_client(self, client, path=None):
573
565
self.clients.remove(client)
574
566
if path is None:
575
567
path = client.proxy.object_path
576
568
del self.clients_dict[path]
577
569
self.refresh()
578
570
579
571
def refresh(self):
580
572
"""Redraw the screen"""
581
573
canvas = self.topwidget.render(self.size, focus=True)
582
574
self.screen.draw_screen(self.size, canvas)
583
575
584
576
def run(self):
585
577
"""Start the main loop and exit when it's done."""
586
578
self.bus = dbus.SystemBus()
587
579
mandos_dbus_objc = self.bus.get_object(
588
580
self.busname, "/", follow_name_owner_changes=True)
589
self.mandos_serv = dbus.Interface(
590
mandos_dbus_objc, dbus_interface=server_interface)
581
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
582
dbus_interface
583
= server_interface)
591
584
try:
592
585
mandos_clients = (self.mandos_serv
593
586
.GetAllClientsWithProperties())
594
587
if not mandos_clients:
595
self.log_message_raw(("bold",
596
"Note: Server has no clients."))
588
self.log_message_raw(("bold", "Note: Server has no clients."))
597
589
except dbus.exceptions.DBusException:
598
self.log_message_raw(("bold",
599
"Note: No Mandos server running."))
590
self.log_message_raw(("bold", "Note: No Mandos server running."))
600
591
mandos_clients = dbus.Dictionary()
601
592
602
593
(self.mandos_serv
603
.connect_to_signal("InterfacesRemoved",
594
.connect_to_signal("ClientRemoved",
604
595
self.find_and_remove_client,
605
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
596
dbus_interface=server_interface,
606
597
byte_arrays=True))
607
598
(self.mandos_serv
608
.connect_to_signal("InterfacesAdded",
599
.connect_to_signal("ClientAdded",
609
600
self.add_new_client,
610
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
601
dbus_interface=server_interface,
611
602
byte_arrays=True))
612
603
(self.mandos_serv
613
604
.connect_to_signal("ClientNotFound",
617
608
for path, client in mandos_clients.items():
618
609
client_proxy_object = self.bus.get_object(self.busname,
619
610
path)
620
self.add_client(MandosClientWidget(
621
server_proxy_object=self.mandos_serv,
622
proxy_object=client_proxy_object,
623
properties=client,
624
update_hook=self.refresh,
625
delete_hook=self.remove_client,
626
logger=self.log_message),
611
self.add_client(MandosClientWidget(server_proxy_object
612
=self.mandos_serv,
613
proxy_object
614
=client_proxy_object,
615
properties=client,
616
update_hook
617
=self.refresh,
618
delete_hook
619
=self.remove_client,
620
logger
621
=self.log_message),
627
622
path=path)
628
623
629
624
self.refresh()
630
self._input_callback_tag = (GLib.io_add_watch
625
self._input_callback_tag = (gobject.io_add_watch
631
626
(sys.stdin.fileno(),
632
GLib.IO_IN,
627
gobject.IO_IN,
633
628
self.process_input))
634
629
self.main_loop.run()
635
630
# Main loop has finished, we should close everything now
636
GLib.source_remove(self._input_callback_tag)
631
gobject.source_remove(self._input_callback_tag)
637
632
self.screen.stop()
638
633
639
634
def stop(self):
640
635
self.main_loop.quit()
641
636
642
637
def process_input(self, source, condition):
643
638
keys = self.screen.get_input()
644
translations = {"ctrl n": "down", # Emacs
645
"ctrl p": "up", # Emacs
646
"ctrl v": "page down", # Emacs
647
"meta v": "page up", # Emacs
648
" ": "page down", # less
649
"f": "page down", # less
650
"b": "page up", # less
651
"j": "down", # vi
652
"k": "up", # vi
653
}
639
translations = { "ctrl n": "down", # Emacs
640
"ctrl p": "up", # Emacs
641
"ctrl v": "page down", # Emacs
642
"meta v": "page up", # Emacs
643
" ": "page down", # less
644
"f": "page down", # less
645
"b": "page up", # less
646
"j": "down", # vi
647
"k": "up", # vi
648
}
654
649
for key in keys:
655
650
try:
656
651
key = translations[key]
657
652
except KeyError: # :-)
658
653
pass
659
654
660
655
if key == "q" or key == "Q":
661
656
self.stop()
662
657
break
710
705
else:
711
706
self.log_level = 0
712
707
self.log_message("Verbose mode: On")
713
# elif (key == "end" or key == "meta >" or key == "G"
714
# or key == ">"):
715
# pass # xxx end-of-buffer
716
# elif (key == "home" or key == "meta <" or key == "g"
717
# or key == "<"):
718
# pass # xxx beginning-of-buffer
719
# elif key == "ctrl e" or key == "$":
720
# pass # xxx move-end-of-line
721
# elif key == "ctrl a" or key == "^":
722
# pass # xxx move-beginning-of-line
723
# elif key == "ctrl b" or key == "meta (" or key == "h":
724
# pass # xxx left
725
# elif key == "ctrl f" or key == "meta )" or key == "l":
726
# pass # xxx right
727
# elif key == "a":
728
# pass # scroll up log
729
# elif key == "z":
730
# pass # scroll down log
708
#elif (key == "end" or key == "meta >" or key == "G"
709
# or key == ">"):
710
# pass # xxx end-of-buffer
711
#elif (key == "home" or key == "meta <" or key == "g"
712
# or key == "<"):
713
# pass # xxx beginning-of-buffer
714
#elif key == "ctrl e" or key == "$":
715
# pass # xxx move-end-of-line
716
#elif key == "ctrl a" or key == "^":
717
# pass # xxx move-beginning-of-line
718
#elif key == "ctrl b" or key == "meta (" or key == "h":
719
# pass # xxx left
720
#elif key == "ctrl f" or key == "meta )" or key == "l":
721
# pass # xxx right
722
#elif key == "a":
723
# pass # scroll up log
724
#elif key == "z":
725
# pass # scroll down log
731
726
elif self.topwidget.selectable():
732
727
self.topwidget.keypress(self.size, key)
733
728
self.refresh()
734
729
return True
735
730
736
737
731
ui = UserInterface()
738
732
try:
739
733
ui.run()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0