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 1161
- compare with another revision
- download diff
- download tarball
- view history from revision 1161
- Committer: Teddy Hogeborn
- Date: 2019-08-18 04:14:31 UTC
- Revision ID: teddy@recompile.se-20190818041431-jgt8pizlzjvxalj0
Debian package: Client: Install the systemd sysusers.d file
* debian/mandos-client.dirs (usr/lib/sysusers.d): New.
* debian/mandos-client.dirs (usr/lib/sysusers.d): New.
- files added:
- debian/mandos-client.templates
- debian/tests
- dracut-module
- files removed:
- initramfs-tools-hook-conf
- files modified:
- .bzrignore
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-2016 Teddy Hogeborn
7
# Copyright © 2009-2016 Björn Påhlsson
8
#
9
# This program is free software: you can redistribute it and/or modify
10
# it under the terms of the GNU General Public License as published by
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
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)
45
46
46
47
import locale
47
48
49
import logging
50
48
51
if sys.version_info.major == 2:
49
52
str = unicode
50
53
51
54
locale.setlocale(locale.LC_ALL, '')
52
55
53
import logging
54
56
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
55
57
56
58
# Some useful constants
57
59
domain = 'se.recompile'
58
60
server_interface = domain + '.Mandos'
59
61
client_interface = domain + '.Mandos.Client'
60
version = "1.7.7"
62
version = "1.8.7"
61
63
62
64
try:
63
65
dbus.OBJECT_MANAGER_IFACE
64
66
except AttributeError:
65
67
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
66
68
69
67
70
def isoformat_to_datetime(iso):
68
71
"Parse an ISO 8601 date string to a datetime.datetime()"
69
72
if not iso:
77
80
int(day),
78
81
int(hour),
79
82
int(minute),
80
int(second), # Whole seconds
81
int(fraction*1000000)) # Microseconds
83
int(second), # Whole seconds
84
int(fraction*1000000)) # Microseconds
85
82
86
83
87
class MandosClientPropertyCache(object):
84
88
"""This wraps a Mandos Client D-Bus proxy object, caches the
86
90
changed.
87
91
"""
88
92
def __init__(self, proxy_object=None, properties=None, **kwargs):
89
self.proxy = proxy_object # Mandos Client proxy object
93
self.proxy = proxy_object # Mandos Client proxy object
90
94
self.properties = dict() if properties is None else properties
91
95
self.property_changed_match = (
92
96
self.proxy.connect_to_signal("PropertiesChanged",
93
97
self.properties_changed,
94
98
dbus.PROPERTIES_IFACE,
95
99
byte_arrays=True))
96
100
97
101
if properties is None:
98
self.properties.update(
99
self.proxy.GetAll(client_interface,
100
dbus_interface
101
= dbus.PROPERTIES_IFACE))
102
102
self.properties.update(self.proxy.GetAll(
103
client_interface,
104
dbus_interface=dbus.PROPERTIES_IFACE))
105
103
106
super(MandosClientPropertyCache, self).__init__(**kwargs)
104
107
105
108
def properties_changed(self, interface, properties, invalidated):
106
109
"""This is called whenever we get a PropertiesChanged signal
107
110
It updates the changed properties in the "properties" dict.
109
112
# Update properties dict with new value
110
113
if interface == client_interface:
111
114
self.properties.update(properties)
112
115
113
116
def delete(self):
114
117
self.property_changed_match.remove()
115
118
117
120
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
118
121
"""A Mandos Client which is visible on the screen.
119
122
"""
120
123
121
124
def __init__(self, server_proxy_object=None, update_hook=None,
122
125
delete_hook=None, logger=None, **kwargs):
123
126
# Called on update
128
131
self.server_proxy_object = server_proxy_object
129
132
# Logger
130
133
self.logger = logger
131
134
132
135
self._update_timer_callback_tag = None
133
136
134
137
# The widget shown normally
135
138
self._text_widget = urwid.Text("")
136
139
# The widget shown when we have focus
138
141
super(MandosClientWidget, self).__init__(**kwargs)
139
142
self.update()
140
143
self.opened = False
141
144
142
145
self.match_objects = (
143
146
self.proxy.connect_to_signal("CheckerCompleted",
144
147
self.checker_completed,
162
165
byte_arrays=True))
163
166
self.logger('Created client {}'
164
167
.format(self.properties["Name"]), level=0)
165
168
166
169
def using_timer(self, flag):
167
170
"""Call this method with True or False when timer should be
168
171
activated or deactivated.
175
178
elif not (flag or self._update_timer_callback_tag is None):
176
179
GLib.source_remove(self._update_timer_callback_tag)
177
180
self._update_timer_callback_tag = None
178
181
179
182
def checker_completed(self, exitstatus, condition, command):
180
183
if exitstatus == 0:
181
184
self.logger('Checker for client {} (command "{}")'
195
198
.format(self.properties["Name"], command,
196
199
os.WTERMSIG(condition)))
197
200
self.update()
198
201
199
202
def checker_started(self, command):
200
203
"""Server signals that a checker started."""
201
204
self.logger('Client {} started checker "{}"'
202
205
.format(self.properties["Name"],
203
206
command), level=0)
204
207
205
208
def got_secret(self):
206
209
self.logger('Client {} received its secret'
207
210
.format(self.properties["Name"]))
208
211
209
212
def need_approval(self, timeout, default):
210
213
if not default:
211
214
message = 'Client {} needs approval within {} seconds'
213
216
message = 'Client {} will get its secret in {} seconds'
214
217
self.logger(message.format(self.properties["Name"],
215
218
timeout/1000))
216
219
217
220
def rejected(self, reason):
218
221
self.logger('Client {} was rejected; reason: {}'
219
222
.format(self.properties["Name"], reason))
220
223
221
224
def selectable(self):
222
225
"""Make this a "selectable" widget.
223
226
This overrides the method from urwid.FlowWidget."""
224
227
return True
225
228
226
229
def rows(self, maxcolrow, focus=False):
227
230
"""How many rows this widget will occupy might depend on
228
231
whether we have focus or not.
229
232
This overrides the method from urwid.FlowWidget"""
230
233
return self.current_widget(focus).rows(maxcolrow, focus=focus)
231
234
232
235
def current_widget(self, focus=False):
233
236
if focus or self.opened:
234
237
return self._focus_widget
235
238
return self._widget
236
239
237
240
def update(self):
238
241
"Called when what is visible on the screen should be updated."
239
242
# How to add standout mode to a style
240
with_standout = { "normal": "standout",
241
"bold": "bold-standout",
242
"underline-blink":
243
"underline-blink-standout",
244
"bold-underline-blink":
245
"bold-underline-blink-standout",
246
}
247
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
248
251
# Rebuild focus and non-focus widgets using current properties
249
252
250
253
# Base part of a client. Name!
251
254
base = '{name}: '.format(name=self.properties["Name"])
252
255
if not self.properties["Enabled"]:
253
256
message = "DISABLED"
254
257
self.using_timer(False)
255
258
elif self.properties["ApprovalPending"]:
256
timeout = datetime.timedelta(milliseconds
257
= self.properties
258
["ApprovalDelay"])
259
timeout = datetime.timedelta(
260
milliseconds=self.properties["ApprovalDelay"])
259
261
last_approval_request = isoformat_to_datetime(
260
262
self.properties["LastApprovalRequest"])
261
263
if last_approval_request is not None:
288
290
message = "enabled"
289
291
self.using_timer(False)
290
292
self._text = "{}{}".format(base, message)
291
293
292
294
if not urwid.supports_unicode():
293
295
self._text = self._text.encode("ascii", "replace")
294
296
textlist = [("normal", self._text)]
304
306
# Run update hook, if any
305
307
if self.update_hook is not None:
306
308
self.update_hook()
307
309
308
310
def update_timer(self):
309
311
"""called by GLib. Will indefinitely loop until
310
312
GLib.source_remove() on tag is called
311
313
"""
312
314
self.update()
313
315
return True # Keep calling this
314
316
315
317
def delete(self, **kwargs):
316
318
if self._update_timer_callback_tag is not None:
317
319
GLib.source_remove(self._update_timer_callback_tag)
322
324
if self.delete_hook is not None:
323
325
self.delete_hook(self)
324
326
return super(MandosClientWidget, self).delete(**kwargs)
325
327
326
328
def render(self, maxcolrow, focus=False):
327
329
"""Render differently if we have focus.
328
330
This overrides the method from urwid.FlowWidget"""
329
331
return self.current_widget(focus).render(maxcolrow,
330
332
focus=focus)
331
333
332
334
def keypress(self, maxcolrow, key):
333
335
"""Handle keys.
334
336
This overrides the method from urwid.FlowWidget"""
335
337
if key == "+":
336
338
self.proxy.Set(client_interface, "Enabled",
337
dbus.Boolean(True), ignore_reply = True,
338
dbus_interface = dbus.PROPERTIES_IFACE)
339
dbus.Boolean(True), ignore_reply=True,
340
dbus_interface=dbus.PROPERTIES_IFACE)
339
341
elif key == "-":
340
342
self.proxy.Set(client_interface, "Enabled", False,
341
ignore_reply = True,
342
dbus_interface = dbus.PROPERTIES_IFACE)
343
ignore_reply=True,
344
dbus_interface=dbus.PROPERTIES_IFACE)
343
345
elif key == "a":
344
346
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
345
dbus_interface = client_interface,
347
dbus_interface=client_interface,
346
348
ignore_reply=True)
347
349
elif key == "d":
348
350
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
349
dbus_interface = client_interface,
351
dbus_interface=client_interface,
350
352
ignore_reply=True)
351
353
elif key == "R" or key == "_" or key == "ctrl k":
352
354
self.server_proxy_object.RemoveClient(self.proxy
354
356
ignore_reply=True)
355
357
elif key == "s":
356
358
self.proxy.Set(client_interface, "CheckerRunning",
357
dbus.Boolean(True), ignore_reply = True,
358
dbus_interface = dbus.PROPERTIES_IFACE)
359
dbus.Boolean(True), ignore_reply=True,
360
dbus_interface=dbus.PROPERTIES_IFACE)
359
361
elif key == "S":
360
362
self.proxy.Set(client_interface, "CheckerRunning",
361
dbus.Boolean(False), ignore_reply = True,
362
dbus_interface = dbus.PROPERTIES_IFACE)
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
self.log = []
447
self.log = urwid.SimpleListWalker([])
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
468
self.main_loop = GLib.MainLoop()
467
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]
505
self.logbox.set_focus(len(self.logbox.body.contents),
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]
506
self.logbox.set_focus(len(self.logbox.body.contents)-1,
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
528
529
def find_and_remove_client(self, path, interfaces):
529
530
"""Find a client by its object path and remove it.
530
531
531
532
This is connected to the InterfacesRemoved signal from the
532
533
Mandos server object."""
533
534
if client_interface not in interfaces:
541
542
.format(path))
542
543
return
543
544
client.delete()
544
545
545
546
def add_new_client(self, path, ifs_and_props):
546
547
"""Find a client by its object path and remove it.
547
548
548
549
This is connected to the InterfacesAdded signal from the
549
550
Mandos server object.
550
551
"""
552
553
# Not a Mandos client object; ignore
553
554
return
554
555
client_proxy_object = self.bus.get_object(self.busname, path)
555
self.add_client(MandosClientWidget(server_proxy_object
556
=self.mandos_serv,
557
proxy_object
558
=client_proxy_object,
559
update_hook
560
=self.refresh,
561
delete_hook
562
=self.remove_client,
563
logger
564
=self.log_message,
565
properties
566
= dict(ifs_and_props[
567
client_interface])),
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])),
568
563
path=path)
569
564
570
565
def add_client(self, client, path=None):
571
566
self.clients.append(client)
572
567
if path is None:
574
569
self.clients_dict[path] = client
575
570
self.clients.sort(key=lambda c: c.properties["Name"])
576
571
self.refresh()
577
572
578
573
def remove_client(self, client, path=None):
579
574
self.clients.remove(client)
580
575
if path is None:
581
576
path = client.proxy.object_path
582
577
del self.clients_dict[path]
583
578
self.refresh()
584
579
585
580
def refresh(self):
586
581
"""Redraw the screen"""
587
582
canvas = self.topwidget.render(self.size, focus=True)
588
583
self.screen.draw_screen(self.size, canvas)
589
584
590
585
def run(self):
591
586
"""Start the main loop and exit when it's done."""
592
587
self.bus = dbus.SystemBus()
593
588
mandos_dbus_objc = self.bus.get_object(
594
589
self.busname, "/", follow_name_owner_changes=True)
595
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
596
dbus_interface
597
= server_interface)
590
self.mandos_serv = dbus.Interface(
591
mandos_dbus_objc, dbus_interface=server_interface)
598
592
try:
599
593
mandos_clients = (self.mandos_serv
600
594
.GetAllClientsWithProperties())
601
595
if not mandos_clients:
602
self.log_message_raw(("bold", "Note: Server has no clients."))
596
self.log_message_raw(("bold",
597
"Note: Server has no clients."))
603
598
except dbus.exceptions.DBusException:
604
self.log_message_raw(("bold", "Note: No Mandos server running."))
599
self.log_message_raw(("bold",
600
"Note: No Mandos server running."))
605
601
mandos_clients = dbus.Dictionary()
606
602
607
603
(self.mandos_serv
608
604
.connect_to_signal("InterfacesRemoved",
609
605
self.find_and_remove_client,
610
dbus_interface
611
= dbus.OBJECT_MANAGER_IFACE,
606
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
612
607
byte_arrays=True))
613
608
(self.mandos_serv
614
609
.connect_to_signal("InterfacesAdded",
615
610
self.add_new_client,
616
dbus_interface
617
= dbus.OBJECT_MANAGER_IFACE,
611
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
618
612
byte_arrays=True))
619
613
(self.mandos_serv
620
614
.connect_to_signal("ClientNotFound",
624
618
for path, client in mandos_clients.items():
625
619
client_proxy_object = self.bus.get_object(self.busname,
626
620
path)
627
self.add_client(MandosClientWidget(server_proxy_object
628
=self.mandos_serv,
629
proxy_object
630
=client_proxy_object,
631
properties=client,
632
update_hook
633
=self.refresh,
634
delete_hook
635
=self.remove_client,
636
logger
637
=self.log_message),
621
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),
638
628
path=path)
639
629
640
630
self.refresh()
641
631
self._input_callback_tag = (GLib.io_add_watch
642
632
(sys.stdin.fileno(),
646
636
# Main loop has finished, we should close everything now
647
637
GLib.source_remove(self._input_callback_tag)
648
638
self.screen.stop()
649
639
650
640
def stop(self):
651
641
self.main_loop.quit()
652
642
653
643
def process_input(self, source, condition):
654
644
keys = self.screen.get_input()
655
translations = { "ctrl n": "down", # Emacs
656
"ctrl p": "up", # Emacs
657
"ctrl v": "page down", # Emacs
658
"meta v": "page up", # Emacs
659
" ": "page down", # less
660
"f": "page down", # less
661
"b": "page up", # less
662
"j": "down", # vi
663
"k": "up", # vi
664
}
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
}
665
655
for key in keys:
666
656
try:
667
657
key = translations[key]
668
658
except KeyError: # :-)
669
659
pass
670
660
671
661
if key == "q" or key == "Q":
672
662
self.stop()
673
663
break
721
711
else:
722
712
self.log_level = 0
723
713
self.log_message("Verbose mode: On")
724
#elif (key == "end" or key == "meta >" or key == "G"
725
# or key == ">"):
726
# pass # xxx end-of-buffer
727
#elif (key == "home" or key == "meta <" or key == "g"
728
# or key == "<"):
729
# pass # xxx beginning-of-buffer
730
#elif key == "ctrl e" or key == "$":
731
# pass # xxx move-end-of-line
732
#elif key == "ctrl a" or key == "^":
733
# pass # xxx move-beginning-of-line
734
#elif key == "ctrl b" or key == "meta (" or key == "h":
735
# pass # xxx left
736
#elif key == "ctrl f" or key == "meta )" or key == "l":
737
# pass # xxx right
738
#elif key == "a":
739
# pass # scroll up log
740
#elif key == "z":
741
# pass # scroll down log
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
742
732
elif self.topwidget.selectable():
743
733
self.topwidget.keypress(self.size, key)
744
734
self.refresh()
745
735
return True
746
736
737
747
738
ui = UserInterface()
748
739
try:
749
740
ui.run()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0