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 404
- compare with another revision
- download diff
- download tarball
- view history from revision 404
- Committer: Teddy Hogeborn
- Date: 2009-11-05 19:16:46 UTC
- Revision ID: teddy@fukt.bsnet.se-20091105191646-5l7bkq5h4wkh3huh
* mandos-monitor: New prototype version of interactive server
administraton tool using D-Bus.
administraton tool using D-Bus.
- files removed:
- DBUS-API
- debian/source
- files modified:
- .bzrignore
added
removed
mandos-monitor
1
1
#!/usr/bin/python
2
2
# -*- mode: python; coding: utf-8 -*-
3
#
4
# Mandos Monitor - Control and monitor the Mandos server
5
#
6
# Copyright © 2009-2011 Teddy Hogeborn
7
# Copyright © 2009-2011 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
11
# the Free Software Foundation, either version 3 of the License, or
12
# (at your option) any later version.
13
#
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
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17
# GNU General Public License for more details.
18
#
19
# You should have received a copy of the GNU General Public License
20
# along with this program. If not, see <http://www.gnu.org/licenses/>.
21
#
22
# Contact the authors at <mandos@fukt.bsnet.se>.
23
#
24
3
25
from __future__ import division, absolute_import, print_function, unicode_literals
4
from __future__ import division, absolute_import, with_statement
26
5
27
6
import sys
28
import os
29
7
import signal
30
8
31
import datetime
32
33
9
import urwid.curses_display
34
10
import urwid
35
11
40
16
41
17
import UserList
42
18
43
import locale
44
45
locale.setlocale(locale.LC_ALL, '')
46
47
import logging
48
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
49
50
19
# Some useful constants
51
20
domain = 'se.bsnet.fukt'
52
21
server_interface = domain + '.Mandos'
53
22
client_interface = domain + '.Mandos.Client'
54
version = "1.3.0"
23
version = "1.0.14"
55
24
56
25
# Always run in monochrome mode
57
26
urwid.curses_display.curses.has_colors = lambda : False
61
30
urwid.curses_display.curses.A_UNDERLINE |= (
62
31
urwid.curses_display.curses.A_BLINK)
63
32
64
def isoformat_to_datetime(iso):
65
"Parse an ISO 8601 date string to a datetime.datetime()"
66
if not iso:
67
return None
68
d, t = iso.split("T", 1)
69
year, month, day = d.split("-", 2)
70
hour, minute, second = t.split(":", 2)
71
second, fraction = divmod(float(second), 1)
72
return datetime.datetime(int(year),
73
int(month),
74
int(day),
75
int(hour),
76
int(minute),
77
int(second), # Whole seconds
78
int(fraction*1000000)) # Microseconds
79
80
33
class MandosClientPropertyCache(object):
81
34
"""This wraps a Mandos Client D-Bus proxy object, caches the
82
35
properties and calls a hook function when any of them are
83
36
changed.
84
37
"""
85
def __init__(self, proxy_object=None, *args, **kwargs):
38
def __init__(self, proxy_object=None, properties=None, *args,
39
**kwargs):
40
# Type conversion mapping
41
self.type_map = {
42
dbus.ObjectPath: unicode,
43
dbus.ByteArray: str,
44
dbus.Signature: unicode,
45
dbus.Byte: chr,
46
dbus.Int16: int,
47
dbus.UInt16: int,
48
dbus.Int32: int,
49
dbus.UInt32: int,
50
dbus.Int64: int,
51
dbus.UInt64: int,
52
dbus.Dictionary: dict,
53
dbus.Array: list,
54
dbus.String: unicode,
55
dbus.Boolean: bool,
56
dbus.Double: float,
57
dbus.Struct: tuple,
58
}
86
59
self.proxy = proxy_object # Mandos Client proxy object
87
60
88
self.properties = dict()
61
if properties is None:
62
self.properties = dict()
63
else:
64
self.properties = dict(self.convert_property(prop, val)
65
for prop, val in
66
properties.iteritems())
89
67
self.proxy.connect_to_signal("PropertyChanged",
90
68
self.property_changed,
91
69
client_interface,
92
70
byte_arrays=True)
93
71
94
self.properties.update(
95
self.proxy.GetAll(client_interface,
96
dbus_interface = dbus.PROPERTIES_IFACE))
97
98
#XXX This break good super behaviour!
99
# super(MandosClientPropertyCache, self).__init__(
100
# *args, **kwargs)
72
if properties is None:
73
self.properties.update(
74
self.convert_property(prop, val)
75
for prop, val in
76
self.proxy.GetAll(client_interface,
77
dbus_interface =
78
dbus.PROPERTIES_IFACE).iteritems())
79
super(MandosClientPropertyCache, self).__init__(
80
proxy_object=proxy_object,
81
properties=properties, *args, **kwargs)
101
82
83
def convert_property(self, property, value):
84
"""This converts the arguments from a D-Bus signal, which are
85
D-Bus types, into normal Python types, using a conversion
86
function from "self.type_map".
87
"""
88
property_name = unicode(property) # Always a dbus.String
89
if isinstance(value, dbus.UTF8String):
90
# Should not happen, but prepare for it anyway
91
value = dbus.String(str(value).decode("utf-8"))
92
try:
93
convfunc = self.type_map[type(value)]
94
except KeyError:
95
# Unknown type, return unmodified
96
return property_name, value
97
return property_name, convfunc(value)
102
98
def property_changed(self, property=None, value=None):
103
99
"""This is called whenever we get a PropertyChanged signal
104
100
It updates the changed property in the "properties" dict.
105
101
"""
102
# Convert name and value
103
property_name, cvalue = self.convert_property(property, value)
106
104
# Update properties dict with new value
107
self.properties[property] = value
105
self.properties[property_name] = cvalue
108
106
109
107
110
108
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
112
110
"""
113
111
114
112
def __init__(self, server_proxy_object=None, update_hook=None,
115
delete_hook=None, logger=None, *args, **kwargs):
113
delete_hook=None, *args, **kwargs):
116
114
# Called on update
117
115
self.update_hook = update_hook
118
116
# Called on delete
119
117
self.delete_hook = delete_hook
120
118
# Mandos Server proxy object
121
119
self.server_proxy_object = server_proxy_object
122
# Logger
123
self.logger = logger
124
125
self._update_timer_callback_tag = None
126
self._update_timer_callback_lock = 0
127
self.last_checker_failed = False
128
120
129
121
# The widget shown normally
130
122
self._text_widget = urwid.Text("")
135
127
*args, **kwargs)
136
128
self.update()
137
129
self.opened = False
138
139
last_checked_ok = isoformat_to_datetime(self.properties
140
["LastCheckedOK"])
141
if last_checked_ok is None:
142
self.last_checker_failed = True
143
else:
144
self.last_checker_failed = ((datetime.datetime.utcnow()
145
- last_checked_ok)
146
> datetime.timedelta
147
(milliseconds=
148
self.properties
149
["Interval"]))
150
151
if self.last_checker_failed:
152
self.using_timer(True)
153
154
if self.need_approval:
155
self.using_timer(True)
156
157
self.proxy.connect_to_signal("CheckerCompleted",
158
self.checker_completed,
159
client_interface,
160
byte_arrays=True)
161
self.proxy.connect_to_signal("CheckerStarted",
162
self.checker_started,
163
client_interface,
164
byte_arrays=True)
165
self.proxy.connect_to_signal("GotSecret",
166
self.got_secret,
167
client_interface,
168
byte_arrays=True)
169
self.proxy.connect_to_signal("NeedApproval",
170
self.need_approval,
171
client_interface,
172
byte_arrays=True)
173
self.proxy.connect_to_signal("Rejected",
174
self.rejected,
175
client_interface,
176
byte_arrays=True)
177
178
def property_changed(self, property=None, value=None):
179
super(self, MandosClientWidget).property_changed(property,
180
value)
181
if property == "ApprovalPending":
182
using_timer(bool(value))
183
184
def using_timer(self, flag):
185
"""Call this method with True or False when timer should be
186
activated or deactivated.
187
"""
188
old = self._update_timer_callback_lock
189
if flag:
190
self._update_timer_callback_lock += 1
191
else:
192
self._update_timer_callback_lock -= 1
193
if old == 0 and self._update_timer_callback_lock:
194
self._update_timer_callback_tag = (gobject.timeout_add
195
(1000,
196
self.update_timer))
197
elif old and self._update_timer_callback_lock == 0:
198
gobject.source_remove(self._update_timer_callback_tag)
199
self._update_timer_callback_tag = None
200
201
def checker_completed(self, exitstatus, condition, command):
202
if exitstatus == 0:
203
if self.last_checker_failed:
204
self.last_checker_failed = False
205
self.using_timer(False)
206
#self.logger('Checker for client %s (command "%s")'
207
# ' was successful'
208
# % (self.properties["Name"], command))
209
self.update()
210
return
211
# Checker failed
212
if not self.last_checker_failed:
213
self.last_checker_failed = True
214
self.using_timer(True)
215
if os.WIFEXITED(condition):
216
self.logger('Checker for client %s (command "%s")'
217
' failed with exit code %s'
218
% (self.properties["Name"], command,
219
os.WEXITSTATUS(condition)))
220
elif os.WIFSIGNALED(condition):
221
self.logger('Checker for client %s (command "%s")'
222
' was killed by signal %s'
223
% (self.properties["Name"], command,
224
os.WTERMSIG(condition)))
225
elif os.WCOREDUMP(condition):
226
self.logger('Checker for client %s (command "%s")'
227
' dumped core'
228
% (self.properties["Name"], command))
229
else:
230
self.logger('Checker for client %s completed'
231
' mysteriously')
232
self.update()
233
234
def checker_started(self, command):
235
#self.logger('Client %s started checker "%s"'
236
# % (self.properties["Name"], unicode(command)))
237
pass
238
239
def got_secret(self):
240
self.last_checker_failed = False
241
self.logger('Client %s received its secret'
242
% self.properties["Name"])
243
244
def need_approval(self, timeout, default):
245
if not default:
246
message = 'Client %s needs approval within %s seconds'
247
else:
248
message = 'Client %s will get its secret in %s seconds'
249
self.logger(message
250
% (self.properties["Name"], timeout/1000))
251
self.using_timer(True)
252
253
def rejected(self, reason):
254
self.logger('Client %s was rejected; reason: %s'
255
% (self.properties["Name"], reason))
256
130
257
131
def selectable(self):
258
132
"""Make this a "selectable" widget.
259
133
This overrides the method from urwid.FlowWidget."""
260
134
return True
261
135
262
def rows(self, maxcolrow, focus=False):
136
def rows(self, (maxcol,), focus=False):
263
137
"""How many rows this widget will occupy might depend on
264
138
whether we have focus or not.
265
139
This overrides the method from urwid.FlowWidget"""
266
return self.current_widget(focus).rows(maxcolrow, focus=focus)
140
return self.current_widget(focus).rows((maxcol,), focus=focus)
267
141
268
142
def current_widget(self, focus=False):
269
143
if focus or self.opened:
273
147
def update(self):
274
148
"Called when what is visible on the screen should be updated."
275
149
# How to add standout mode to a style
276
with_standout = { "normal": "standout",
277
"bold": "bold-standout",
278
"underline-blink":
279
"underline-blink-standout",
280
"bold-underline-blink":
281
"bold-underline-blink-standout",
150
with_standout = { u"normal": u"standout",
151
u"bold": u"bold-standout",
152
u"underline-blink":
153
u"underline-blink-standout",
154
u"bold-underline-blink":
155
u"bold-underline-blink-standout",
282
156
}
283
157
284
158
# Rebuild focus and non-focus widgets using current properties
285
286
# Base part of a client. Name!
287
base = ('%(name)s: '
288
% {"name": self.properties["Name"]})
289
if not self.properties["Enabled"]:
290
message = "DISABLED"
291
elif self.properties["ApprovalPending"]:
292
timeout = datetime.timedelta(milliseconds
293
= self.properties
294
["ApprovalDelay"])
295
last_approval_request = isoformat_to_datetime(
296
self.properties["LastApprovalRequest"])
297
if last_approval_request is not None:
298
timer = timeout - (datetime.datetime.utcnow()
299
- last_approval_request)
300
else:
301
timer = datetime.timedelta()
302
if self.properties["ApprovedByDefault"]:
303
message = "Approval in %s. (d)eny?"
304
else:
305
message = "Denial in %s. (a)pprove?"
306
message = message % unicode(timer).rsplit(".", 1)[0]
307
elif self.last_checker_failed:
308
timeout = datetime.timedelta(milliseconds
309
= self.properties
310
["Timeout"])
311
last_ok = isoformat_to_datetime(
312
max((self.properties["LastCheckedOK"]
313
or self.properties["Created"]),
314
self.properties["LastEnabled"]))
315
timer = timeout - (datetime.datetime.utcnow() - last_ok)
316
message = ('A checker has failed! Time until client'
317
' gets disabled: %s'
318
% unicode(timer).rsplit(".", 1)[0])
319
else:
320
message = "enabled"
321
self._text = "%s%s" % (base, message)
322
159
self._text = (u'name="%(name)s", enabled=%(enabled)s'
160
% self.properties)
323
161
if not urwid.supports_unicode():
324
162
self._text = self._text.encode("ascii", "replace")
325
textlist = [("normal", self._text)]
163
textlist = [(u"normal", u"BLÄRGH: "), (u"bold", self._text)]
326
164
self._text_widget.set_text(textlist)
327
165
self._focus_text_widget.set_text([(with_standout[text[0]],
328
166
text[1])
336
174
if self.update_hook is not None:
337
175
self.update_hook()
338
176
339
def update_timer(self):
340
"called by gobject"
341
self.update()
342
return True # Keep calling this
343
344
177
def delete(self):
345
if self._update_timer_callback_tag is not None:
346
gobject.source_remove(self._update_timer_callback_tag)
347
self._update_timer_callback_tag = None
348
178
if self.delete_hook is not None:
349
179
self.delete_hook(self)
350
180
351
def render(self, maxcolrow, focus=False):
181
def render(self, (maxcol,), focus=False):
352
182
"""Render differently if we have focus.
353
183
This overrides the method from urwid.FlowWidget"""
354
return self.current_widget(focus).render(maxcolrow,
184
return self.current_widget(focus).render((maxcol,),
355
185
focus=focus)
356
186
357
def keypress(self, maxcolrow, key):
187
def keypress(self, (maxcol,), key):
358
188
"""Handle keys.
359
189
This overrides the method from urwid.FlowWidget"""
360
if key == "+":
361
self.proxy.Enable(dbus_interface = client_interface,
362
ignore_reply=True)
363
elif key == "-":
364
self.proxy.Disable(dbus_interface = client_interface,
365
ignore_reply=True)
366
elif key == "a":
367
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
368
dbus_interface = client_interface,
369
ignore_reply=True)
370
elif key == "d":
371
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
372
dbus_interface = client_interface,
373
ignore_reply=True)
374
elif key == "R" or key == "_" or key == "ctrl k":
190
if key == u"e" or key == u"+":
191
self.proxy.Enable()
192
elif key == u"d" or key == u"-":
193
self.proxy.Disable()
194
elif key == u"r" or key == u"_":
375
195
self.server_proxy_object.RemoveClient(self.proxy
376
.object_path,
377
ignore_reply=True)
378
elif key == "s":
379
self.proxy.StartChecker(dbus_interface = client_interface,
380
ignore_reply=True)
381
elif key == "S":
382
self.proxy.StopChecker(dbus_interface = client_interface,
383
ignore_reply=True)
384
elif key == "C":
385
self.proxy.CheckedOK(dbus_interface = client_interface,
386
ignore_reply=True)
196
.object_path)
197
elif key == u"s":
198
self.proxy.StartChecker()
199
elif key == u"c":
200
self.proxy.StopChecker()
201
elif key == u"S":
202
self.proxy.CheckedOK()
387
203
# xxx
388
# elif key == "p" or key == "=":
204
# elif key == u"p" or key == "=":
389
205
# self.proxy.pause()
390
# elif key == "u" or key == ":":
206
# elif key == u"u" or key == ":":
391
207
# self.proxy.unpause()
392
# elif key == "RET":
208
# elif key == u"RET":
393
209
# self.open()
394
210
else:
395
211
return key
406
222
self.update()
407
223
408
224
409
class ConstrainedListBox(urwid.ListBox):
410
"""Like a normal urwid.ListBox, but will consume all "up" or
411
"down" key presses, thus not allowing any containing widgets to
412
use them as an excuse to shift focus away from this widget.
413
"""
414
def keypress(self, maxcolrow, key):
415
ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)
416
if ret in ("up", "down"):
417
return
418
return ret
419
420
421
225
class UserInterface(object):
422
226
"""This is the entire user interface - the whole screen
423
227
with boxes, lists of client widgets, etc.
424
228
"""
425
def __init__(self, max_log_length=1000):
426
DBusGMainLoop(set_as_default=True)
229
def __init__(self):
230
DBusGMainLoop(set_as_default=True )
427
231
428
232
self.screen = urwid.curses_display.Screen()
429
233
430
234
self.screen.register_palette((
431
("normal",
432
"default", "default", None),
433
("bold",
434
"default", "default", "bold"),
435
("underline-blink",
436
"default", "default", "underline"),
437
("standout",
438
"default", "default", "standout"),
439
("bold-underline-blink",
440
"default", "default", ("bold", "underline")),
441
("bold-standout",
442
"default", "default", ("bold", "standout")),
443
("underline-blink-standout",
444
"default", "default", ("underline", "standout")),
445
("bold-underline-blink-standout",
446
"default", "default", ("bold", "underline",
447
"standout")),
235
(u"normal",
236
u"default", u"default", None),
237
(u"bold",
238
u"default", u"default", u"bold"),
239
(u"underline-blink",
240
u"default", u"default", u"underline"),
241
(u"standout",
242
u"default", u"default", u"standout"),
243
(u"bold-underline-blink",
244
u"default", u"default", (u"bold", u"underline")),
245
(u"bold-standout",
246
u"default", u"default", (u"bold", u"standout")),
247
(u"underline-blink-standout",
248
u"default", u"default", (u"underline", u"standout")),
249
(u"bold-underline-blink-standout",
250
u"default", u"default", (u"bold", u"underline",
251
u"standout")),
448
252
))
449
253
450
if urwid.supports_unicode():
451
self.divider = "─" # \u2500
452
#self.divider = "━" # \u2501
453
else:
454
#self.divider = "-" # \u002d
455
self.divider = "_" # \u005f
456
457
254
self.screen.start()
458
255
459
256
self.size = self.screen.get_cols_rows()
460
257
461
258
self.clients = urwid.SimpleListWalker([])
462
259
self.clients_dict = {}
463
464
# We will add Text widgets to this list
465
self.log = []
466
self.max_log_length = max_log_length
467
468
# We keep a reference to the log widget so we can remove it
469
# from the ListWalker without it getting destroyed
470
self.logbox = ConstrainedListBox(self.log)
471
472
# This keeps track of whether self.uilist currently has
473
# self.logbox in it or not
474
self.log_visible = True
475
self.log_wrap = "any"
476
477
self.rebuild()
478
self.log_message_raw(("bold",
479
"Mandos Monitor version " + version))
480
self.log_message_raw(("bold",
481
"q: Quit ?: Help"))
260
self.topwidget = urwid.LineBox(urwid.ListBox(self.clients))
261
#self.topwidget = urwid.ListBox(clients)
482
262
483
263
self.busname = domain + '.Mandos'
484
264
self.main_loop = gobject.MainLoop()
485
265
self.bus = dbus.SystemBus()
486
266
mandos_dbus_objc = self.bus.get_object(
487
self.busname, "/", follow_name_owner_changes=True)
267
self.busname, u"/", follow_name_owner_changes=True)
488
268
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
489
269
dbus_interface
490
270
= server_interface)
504
284
self.add_new_client,
505
285
dbus_interface=server_interface,
506
286
byte_arrays=True))
507
(self.mandos_serv
508
.connect_to_signal("ClientNotFound",
509
self.client_not_found,
510
dbus_interface=server_interface,
511
byte_arrays=True))
512
for path, client in mandos_clients.iteritems():
287
for path, client in (mandos_clients.iteritems()):
513
288
client_proxy_object = self.bus.get_object(self.busname,
514
289
path)
515
290
self.add_client(MandosClientWidget(server_proxy_object
520
295
update_hook
521
296
=self.refresh,
522
297
delete_hook
523
=self.remove_client,
524
logger
525
=self.log_message),
298
=self.remove_client),
526
299
path=path)
527
300
528
def client_not_found(self, fingerprint, address):
529
self.log_message(("Client with address %s and fingerprint %s"
530
" could not be found" % (address,
531
fingerprint)))
532
533
def rebuild(self):
534
"""This rebuilds the User Interface.
535
Call this when the widget layout needs to change"""
536
self.uilist = []
537
#self.uilist.append(urwid.ListBox(self.clients))
538
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
539
clients),
540
#header=urwid.Divider(),
541
header=None,
542
footer=
543
urwid.Divider(div_char=
544
self.divider)))
545
if self.log_visible:
546
self.uilist.append(self.logbox)
547
pass
548
self.topwidget = urwid.Pile(self.uilist)
549
550
def log_message(self, message):
551
timestamp = datetime.datetime.now().isoformat()
552
self.log_message_raw(timestamp + ": " + message)
553
554
def log_message_raw(self, markup):
555
"""Add a log message to the log buffer."""
556
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
557
if (self.max_log_length
558
and len(self.log) > self.max_log_length):
559
del self.log[0:len(self.log)-self.max_log_length-1]
560
self.logbox.set_focus(len(self.logbox.body.contents),
561
coming_from="above")
562
self.refresh()
563
564
def toggle_log_display(self):
565
"""Toggle visibility of the log buffer."""
566
self.log_visible = not self.log_visible
567
self.rebuild()
568
#self.log_message("Log visibility changed to: "
569
# + unicode(self.log_visible))
570
571
def change_log_display(self):
572
"""Change type of log display.
573
Currently, this toggles wrapping of text lines."""
574
if self.log_wrap == "clip":
575
self.log_wrap = "any"
576
else:
577
self.log_wrap = "clip"
578
for textwidget in self.log:
579
textwidget.set_wrap_mode(self.log_wrap)
580
#self.log_message("Wrap mode: " + self.log_wrap)
581
582
301
def find_and_remove_client(self, path, name):
583
302
"""Find an client from its object path and remove it.
584
303
591
310
return
592
311
self.remove_client(client, path)
593
312
594
def add_new_client(self, path):
313
def add_new_client(self, path, properties):
595
314
client_proxy_object = self.bus.get_object(self.busname, path)
596
315
self.add_client(MandosClientWidget(server_proxy_object
597
316
=self.mandos_serv,
598
317
proxy_object
599
318
=client_proxy_object,
319
properties=properties,
600
320
update_hook
601
321
=self.refresh,
602
322
delete_hook
603
=self.remove_client,
604
logger
605
=self.log_message),
323
=self.remove_client),
606
324
path=path)
607
325
608
326
def add_client(self, client, path=None):
610
328
if path is None:
611
329
path = client.proxy.object_path
612
330
self.clients_dict[path] = client
613
self.clients.sort(None, lambda c: c.properties["Name"])
331
self.clients.sort(None, lambda c: c.properties[u"name"])
614
332
self.refresh()
615
333
616
334
def remove_client(self, client, path=None):
618
336
if path is None:
619
337
path = client.proxy.object_path
620
338
del self.clients_dict[path]
621
if not self.clients_dict:
622
# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
623
# is completely emptied, we need to recreate it.
624
self.clients = urwid.SimpleListWalker([])
625
self.rebuild()
626
339
self.refresh()
627
340
628
341
def refresh(self):
647
360
648
361
def process_input(self, source, condition):
649
362
keys = self.screen.get_input()
650
translations = { "ctrl n": "down", # Emacs
651
"ctrl p": "up", # Emacs
652
"ctrl v": "page down", # Emacs
653
"meta v": "page up", # Emacs
654
" ": "page down", # less
655
"f": "page down", # less
656
"b": "page up", # less
657
"j": "down", # vi
658
"k": "up", # vi
363
translations = { u"j": u"down",
364
u"k": u"up",
659
365
}
660
366
for key in keys:
661
367
try:
663
369
except KeyError: # :-)
664
370
pass
665
371
666
if key == "q" or key == "Q":
372
if key == u"q" or key == u"Q":
667
373
self.stop()
668
374
break
669
elif key == "window resize":
375
elif key == u"window resize":
670
376
self.size = self.screen.get_cols_rows()
671
377
self.refresh()
672
elif key == "\f": # Ctrl-L
673
self.refresh()
674
elif key == "l" or key == "D":
675
self.toggle_log_display()
676
self.refresh()
677
elif key == "w" or key == "i":
678
self.change_log_display()
679
self.refresh()
680
elif key == "?" or key == "f1" or key == "esc":
681
if not self.log_visible:
682
self.log_visible = True
683
self.rebuild()
684
self.log_message_raw(("bold",
685
" ".
686
join(("q: Quit",
687
"?: Help",
688
"l: Log window toggle",
689
"TAB: Switch window",
690
"w: Wrap (log)"))))
691
self.log_message_raw(("bold",
692
" "
693
.join(("Clients:",
694
"+: Enable",
695
"-: Disable",
696
"R: Remove",
697
"s: Start new checker",
698
"S: Stop checker",
699
"C: Checker OK",
700
"a: Approve",
701
"d: Deny"))))
702
self.refresh()
703
elif key == "tab":
704
if self.topwidget.get_focus() is self.logbox:
705
self.topwidget.set_focus(0)
706
else:
707
self.topwidget.set_focus(self.logbox)
708
self.refresh()
709
#elif (key == "end" or key == "meta >" or key == "G"
710
# or key == ">"):
711
# pass # xxx end-of-buffer
712
#elif (key == "home" or key == "meta <" or key == "g"
713
# or key == "<"):
714
# pass # xxx beginning-of-buffer
715
#elif key == "ctrl e" or key == "$":
716
# pass # xxx move-end-of-line
717
#elif key == "ctrl a" or key == "^":
718
# pass # xxx move-beginning-of-line
719
#elif key == "ctrl b" or key == "meta (" or key == "h":
720
# pass # xxx left
721
#elif key == "ctrl f" or key == "meta )" or key == "l":
722
# pass # xxx right
723
#elif key == "a":
724
# pass # scroll up log
725
#elif key == "z":
726
# pass # scroll down log
378
elif key == " ":
379
self.refresh()
727
380
elif self.topwidget.selectable():
728
381
self.topwidget.keypress(self.size, key)
729
382
self.refresh()
732
385
ui = UserInterface()
733
386
try:
734
387
ui.run()
735
except KeyboardInterrupt:
736
ui.screen.stop()
737
except Exception, e:
738
ui.log_message(unicode(e))
388
except:
739
389
ui.screen.stop()
740
390
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0