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