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 24.1.176
- compare with another revision
- download diff
- download tarball
- view history from revision 24.1.176
- Committer: Björn Påhlsson
- Date: 2011-07-25 18:47:45 UTC
- mto: (237.7.37 trunk)
- mto: This revision was merged to the branch mainline in revision 284.
- Revision ID: belorn@fukt.bsnet.se-20110725184745-leavsoyu1hll3mdp
free dirents in password-prompt
- files added:
- 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
#
3
24
4
from __future__ import division, absolute_import, with_statement
25
from __future__ import division, absolute_import, print_function, unicode_literals
5
26
6
27
import sys
28
import os
7
29
import signal
8
30
31
import datetime
32
9
33
import urwid.curses_display
10
34
import urwid
11
35
16
40
17
41
import UserList
18
42
43
import locale
44
45
locale.setlocale(locale.LC_ALL, '')
46
47
import logging
48
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
49
19
50
# Some useful constants
20
51
domain = 'se.bsnet.fukt'
21
52
server_interface = domain + '.Mandos'
22
53
client_interface = domain + '.Mandos.Client'
23
version = "1.0.14"
54
version = "1.3.0"
24
55
25
56
# Always run in monochrome mode
26
57
urwid.curses_display.curses.has_colors = lambda : False
30
61
urwid.curses_display.curses.A_UNDERLINE |= (
31
62
urwid.curses_display.curses.A_BLINK)
32
63
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
33
80
class MandosClientPropertyCache(object):
34
81
"""This wraps a Mandos Client D-Bus proxy object, caches the
35
82
properties and calls a hook function when any of them are
36
83
changed.
37
84
"""
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
}
85
def __init__(self, proxy_object=None, *args, **kwargs):
59
86
self.proxy = proxy_object # Mandos Client proxy object
60
87
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())
88
self.properties = dict()
67
89
self.proxy.connect_to_signal("PropertyChanged",
68
90
self.property_changed,
69
91
client_interface,
70
92
byte_arrays=True)
71
93
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)
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)
82
101
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)
98
102
def property_changed(self, property=None, value=None):
99
103
"""This is called whenever we get a PropertyChanged signal
100
104
It updates the changed property in the "properties" dict.
101
105
"""
102
# Convert name and value
103
property_name, cvalue = self.convert_property(property, value)
104
106
# Update properties dict with new value
105
self.properties[property_name] = cvalue
107
self.properties[property] = value
106
108
107
109
108
110
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
110
112
"""
111
113
112
114
def __init__(self, server_proxy_object=None, update_hook=None,
113
delete_hook=None, *args, **kwargs):
115
delete_hook=None, logger=None, *args, **kwargs):
114
116
# Called on update
115
117
self.update_hook = update_hook
116
118
# Called on delete
117
119
self.delete_hook = delete_hook
118
120
# Mandos Server proxy object
119
121
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
120
128
121
129
# The widget shown normally
122
130
self._text_widget = urwid.Text("")
127
135
*args, **kwargs)
128
136
self.update()
129
137
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))
130
256
131
257
def selectable(self):
132
258
"""Make this a "selectable" widget.
133
259
This overrides the method from urwid.FlowWidget."""
134
260
return True
135
261
136
def rows(self, (maxcol,), focus=False):
262
def rows(self, maxcolrow, focus=False):
137
263
"""How many rows this widget will occupy might depend on
138
264
whether we have focus or not.
139
265
This overrides the method from urwid.FlowWidget"""
140
return self.current_widget(focus).rows((maxcol,), focus=focus)
266
return self.current_widget(focus).rows(maxcolrow, focus=focus)
141
267
142
268
def current_widget(self, focus=False):
143
269
if focus or self.opened:
147
273
def update(self):
148
274
"Called when what is visible on the screen should be updated."
149
275
# How to add standout mode to a style
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",
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",
156
282
}
157
283
158
284
# Rebuild focus and non-focus widgets using current properties
159
self._text = (u'name="%(name)s", enabled=%(enabled)s'
160
% self.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
161
323
if not urwid.supports_unicode():
162
324
self._text = self._text.encode("ascii", "replace")
163
textlist = [(u"normal", u"BLÄRGH: "), (u"bold", self._text)]
325
textlist = [("normal", self._text)]
164
326
self._text_widget.set_text(textlist)
165
327
self._focus_text_widget.set_text([(with_standout[text[0]],
166
328
text[1])
174
336
if self.update_hook is not None:
175
337
self.update_hook()
176
338
339
def update_timer(self):
340
"called by gobject"
341
self.update()
342
return True # Keep calling this
343
177
344
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
178
348
if self.delete_hook is not None:
179
349
self.delete_hook(self)
180
350
181
def render(self, (maxcol,), focus=False):
351
def render(self, maxcolrow, focus=False):
182
352
"""Render differently if we have focus.
183
353
This overrides the method from urwid.FlowWidget"""
184
return self.current_widget(focus).render((maxcol,),
354
return self.current_widget(focus).render(maxcolrow,
185
355
focus=focus)
186
356
187
def keypress(self, (maxcol,), key):
357
def keypress(self, maxcolrow, key):
188
358
"""Handle keys.
189
359
This overrides the method from urwid.FlowWidget"""
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"_":
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":
195
375
self.server_proxy_object.RemoveClient(self.proxy
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()
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)
203
387
# xxx
204
# elif key == u"p" or key == "=":
388
# elif key == "p" or key == "=":
205
389
# self.proxy.pause()
206
# elif key == u"u" or key == ":":
390
# elif key == "u" or key == ":":
207
391
# self.proxy.unpause()
208
# elif key == u"RET":
392
# elif key == "RET":
209
393
# self.open()
210
394
else:
211
395
return key
222
406
self.update()
223
407
224
408
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
225
421
class UserInterface(object):
226
422
"""This is the entire user interface - the whole screen
227
423
with boxes, lists of client widgets, etc.
228
424
"""
229
def __init__(self):
230
DBusGMainLoop(set_as_default=True )
425
def __init__(self, max_log_length=1000):
426
DBusGMainLoop(set_as_default=True)
231
427
232
428
self.screen = urwid.curses_display.Screen()
233
429
234
430
self.screen.register_palette((
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")),
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")),
252
448
))
253
449
450
if urwid.supports_unicode():
451
self.divider = "─" # \u2500
452
#self.divider = "━" # \u2501
453
else:
454
#self.divider = "-" # \u002d
455
self.divider = "_" # \u005f
456
254
457
self.screen.start()
255
458
256
459
self.size = self.screen.get_cols_rows()
257
460
258
461
self.clients = urwid.SimpleListWalker([])
259
462
self.clients_dict = {}
260
self.topwidget = urwid.LineBox(urwid.ListBox(self.clients))
261
#self.topwidget = urwid.ListBox(clients)
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"))
262
482
263
483
self.busname = domain + '.Mandos'
264
484
self.main_loop = gobject.MainLoop()
265
485
self.bus = dbus.SystemBus()
266
486
mandos_dbus_objc = self.bus.get_object(
267
self.busname, u"/", follow_name_owner_changes=True)
487
self.busname, "/", follow_name_owner_changes=True)
268
488
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
269
489
dbus_interface
270
490
= server_interface)
284
504
self.add_new_client,
285
505
dbus_interface=server_interface,
286
506
byte_arrays=True))
287
for path, client in (mandos_clients.iteritems()):
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():
288
513
client_proxy_object = self.bus.get_object(self.busname,
289
514
path)
290
515
self.add_client(MandosClientWidget(server_proxy_object
295
520
update_hook
296
521
=self.refresh,
297
522
delete_hook
298
=self.remove_client),
523
=self.remove_client,
524
logger
525
=self.log_message),
299
526
path=path)
300
527
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
301
582
def find_and_remove_client(self, path, name):
302
583
"""Find an client from its object path and remove it.
303
584
310
591
return
311
592
self.remove_client(client, path)
312
593
313
def add_new_client(self, path, properties):
594
def add_new_client(self, path):
314
595
client_proxy_object = self.bus.get_object(self.busname, path)
315
596
self.add_client(MandosClientWidget(server_proxy_object
316
597
=self.mandos_serv,
317
598
proxy_object
318
599
=client_proxy_object,
319
properties=properties,
320
600
update_hook
321
601
=self.refresh,
322
602
delete_hook
323
=self.remove_client),
603
=self.remove_client,
604
logger
605
=self.log_message),
324
606
path=path)
325
607
326
608
def add_client(self, client, path=None):
328
610
if path is None:
329
611
path = client.proxy.object_path
330
612
self.clients_dict[path] = client
331
self.clients.sort(None, lambda c: c.properties[u"name"])
613
self.clients.sort(None, lambda c: c.properties["Name"])
332
614
self.refresh()
333
615
334
616
def remove_client(self, client, path=None):
336
618
if path is None:
337
619
path = client.proxy.object_path
338
620
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()
339
626
self.refresh()
340
627
341
628
def refresh(self):
360
647
361
648
def process_input(self, source, condition):
362
649
keys = self.screen.get_input()
363
translations = { u"j": u"down",
364
u"k": u"up",
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
365
659
}
366
660
for key in keys:
367
661
try:
369
663
except KeyError: # :-)
370
664
pass
371
665
372
if key == u"q" or key == u"Q":
666
if key == "q" or key == "Q":
373
667
self.stop()
374
668
break
375
elif key == u"window resize":
669
elif key == "window resize":
376
670
self.size = self.screen.get_cols_rows()
377
671
self.refresh()
378
elif key == " ":
379
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
380
727
elif self.topwidget.selectable():
381
728
self.topwidget.keypress(self.size, key)
382
729
self.refresh()
385
732
ui = UserInterface()
386
733
try:
387
734
ui.run()
388
except:
735
except KeyboardInterrupt:
736
ui.screen.stop()
737
except Exception, e:
738
ui.log_message(unicode(e))
389
739
ui.screen.stop()
390
740
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0