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