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