/mandos/trunk

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

  • Committer: teddy at bsnet
  • Date: 2010-10-01 18:40:55 UTC
  • Revision ID: teddy@fukt.bsnet.se-20101001184055-y2ws8u0edf81dle6
* debian/control (Standards-Version): Updated to "3.9.1".
* mandos-keygen: Use "set -e" as per Debian Policy section 10.4.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-monitor
3
3
# 
4
4
# Mandos Monitor - Control and monitor the Mandos server
5
5
# 
6
 
# Copyright © 2009-2011 Teddy Hogeborn
7
 
# Copyright © 2009-2011 Björn Påhlsson
 
6
# Copyright © 2009,2010 Teddy Hogeborn
 
7
# Copyright © 2009,2010 Björn Påhlsson
8
8
# 
9
9
# This program is free software: you can redistribute it and/or modify
10
10
# it under the terms of the GNU General Public License as published by
22
22
# Contact the authors at <mandos@fukt.bsnet.se>.
23
23
# 
24
24
 
25
 
from __future__ import division, absolute_import, print_function, unicode_literals
 
25
from __future__ import division, absolute_import, with_statement
26
26
 
27
27
import sys
28
28
import os
42
42
 
43
43
import locale
44
44
 
45
 
locale.setlocale(locale.LC_ALL, '')
 
45
locale.setlocale(locale.LC_ALL, u'')
46
46
 
47
47
import logging
48
48
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
51
51
domain = 'se.bsnet.fukt'
52
52
server_interface = domain + '.Mandos'
53
53
client_interface = domain + '.Mandos.Client'
54
 
version = "1.3.0"
 
54
version = "1.2"
55
55
 
56
56
# Always run in monochrome mode
57
57
urwid.curses_display.curses.has_colors = lambda : False
65
65
    "Parse an ISO 8601 date string to a datetime.datetime()"
66
66
    if not iso:
67
67
        return None
68
 
    d, t = iso.split("T", 1)
69
 
    year, month, day = d.split("-", 2)
70
 
    hour, minute, second = t.split(":", 2)
 
68
    d, t = iso.split(u"T", 1)
 
69
    year, month, day = d.split(u"-", 2)
 
70
    hour, minute, second = t.split(u":", 2)
71
71
    second, fraction = divmod(float(second), 1)
72
72
    return datetime.datetime(int(year),
73
73
                             int(month),
86
86
        self.proxy = proxy_object # Mandos Client proxy object
87
87
        
88
88
        self.properties = dict()
89
 
        self.proxy.connect_to_signal("PropertyChanged",
 
89
        self.proxy.connect_to_signal(u"PropertyChanged",
90
90
                                     self.property_changed,
91
91
                                     client_interface,
92
92
                                     byte_arrays=True)
127
127
        self.last_checker_failed = False
128
128
        
129
129
        # The widget shown normally
130
 
        self._text_widget = urwid.Text("")
 
130
        self._text_widget = urwid.Text(u"")
131
131
        # The widget shown when we have focus
132
 
        self._focus_text_widget = urwid.Text("")
 
132
        self._focus_text_widget = urwid.Text(u"")
133
133
        super(MandosClientWidget, self).__init__(
134
134
            update_hook=update_hook, delete_hook=delete_hook,
135
135
            *args, **kwargs)
137
137
        self.opened = False
138
138
        
139
139
        last_checked_ok = isoformat_to_datetime(self.properties
140
 
                                                ["LastCheckedOK"])
 
140
                                                [u"LastCheckedOK"])
141
141
        if last_checked_ok is None:
142
142
            self.last_checker_failed = True
143
143
        else:
146
146
                                        > datetime.timedelta
147
147
                                        (milliseconds=
148
148
                                         self.properties
149
 
                                         ["Interval"]))
 
149
                                         [u"Interval"]))
150
150
        
151
151
        if self.last_checker_failed:
152
152
            self.using_timer(True)
154
154
        if self.need_approval:
155
155
            self.using_timer(True)
156
156
        
157
 
        self.proxy.connect_to_signal("CheckerCompleted",
 
157
        self.proxy.connect_to_signal(u"CheckerCompleted",
158
158
                                     self.checker_completed,
159
159
                                     client_interface,
160
160
                                     byte_arrays=True)
161
 
        self.proxy.connect_to_signal("CheckerStarted",
 
161
        self.proxy.connect_to_signal(u"CheckerStarted",
162
162
                                     self.checker_started,
163
163
                                     client_interface,
164
164
                                     byte_arrays=True)
165
 
        self.proxy.connect_to_signal("GotSecret",
 
165
        self.proxy.connect_to_signal(u"GotSecret",
166
166
                                     self.got_secret,
167
167
                                     client_interface,
168
168
                                     byte_arrays=True)
169
 
        self.proxy.connect_to_signal("NeedApproval",
 
169
        self.proxy.connect_to_signal(u"NeedApproval",
170
170
                                     self.need_approval,
171
171
                                     client_interface,
172
172
                                     byte_arrays=True)
173
 
        self.proxy.connect_to_signal("Rejected",
 
173
        self.proxy.connect_to_signal(u"Rejected",
174
174
                                     self.rejected,
175
175
                                     client_interface,
176
176
                                     byte_arrays=True)
178
178
    def property_changed(self, property=None, value=None):
179
179
        super(self, MandosClientWidget).property_changed(property,
180
180
                                                         value)
181
 
        if property == "ApprovalPending":
 
181
        if property == u"ApprovalPending":
182
182
            using_timer(bool(value))
183
183
        
184
184
    def using_timer(self, flag):
203
203
            if self.last_checker_failed:
204
204
                self.last_checker_failed = False
205
205
                self.using_timer(False)
206
 
            #self.logger('Checker for client %s (command "%s")'
207
 
            #            ' was successful'
208
 
            #            % (self.properties["Name"], command))
 
206
            #self.logger(u'Checker for client %s (command "%s")'
 
207
            #            u' was successful'
 
208
            #            % (self.properties[u"Name"], command))
209
209
            self.update()
210
210
            return
211
211
        # Checker failed
213
213
            self.last_checker_failed = True
214
214
            self.using_timer(True)
215
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,
 
216
            self.logger(u'Checker for client %s (command "%s")'
 
217
                        u' failed with exit code %s'
 
218
                        % (self.properties[u"Name"], command,
219
219
                           os.WEXITSTATUS(condition)))
220
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,
 
221
            self.logger(u'Checker for client %s (command "%s")'
 
222
                        u' was killed by signal %s'
 
223
                        % (self.properties[u"Name"], command,
224
224
                           os.WTERMSIG(condition)))
225
225
        elif os.WCOREDUMP(condition):
226
 
            self.logger('Checker for client %s (command "%s")'
227
 
                        ' dumped core'
228
 
                        % (self.properties["Name"], command))
 
226
            self.logger(u'Checker for client %s (command "%s")'
 
227
                        u' dumped core'
 
228
                        % (self.properties[u"Name"], command))
229
229
        else:
230
 
            self.logger('Checker for client %s completed'
231
 
                        ' mysteriously')
 
230
            self.logger(u'Checker for client %s completed'
 
231
                        u' mysteriously')
232
232
        self.update()
233
233
    
234
234
    def checker_started(self, command):
235
 
        #self.logger('Client %s started checker "%s"'
236
 
        #            % (self.properties["Name"], unicode(command)))
 
235
        #self.logger(u'Client %s started checker "%s"'
 
236
        #            % (self.properties[u"Name"], unicode(command)))
237
237
        pass
238
238
    
239
239
    def got_secret(self):
240
240
        self.last_checker_failed = False
241
 
        self.logger('Client %s received its secret'
242
 
                    % self.properties["Name"])
 
241
        self.logger(u'Client %s received its secret'
 
242
                    % self.properties[u"Name"])
243
243
    
244
244
    def need_approval(self, timeout, default):
245
245
        if not default:
246
 
            message = 'Client %s needs approval within %s seconds'
 
246
            message = u'Client %s needs approval within %s seconds'
247
247
        else:
248
 
            message = 'Client %s will get its secret in %s seconds'
 
248
            message = u'Client %s will get its secret in %s seconds'
249
249
        self.logger(message
250
 
                    % (self.properties["Name"], timeout/1000))
 
250
                    % (self.properties[u"Name"], timeout/1000))
251
251
        self.using_timer(True)
252
252
    
253
253
    def rejected(self, reason):
254
 
        self.logger('Client %s was rejected; reason: %s'
255
 
                    % (self.properties["Name"], reason))
 
254
        self.logger(u'Client %s was rejected; reason: %s'
 
255
                    % (self.properties[u"Name"], reason))
256
256
    
257
257
    def selectable(self):
258
258
        """Make this a "selectable" widget.
259
259
        This overrides the method from urwid.FlowWidget."""
260
260
        return True
261
261
    
262
 
    def rows(self, maxcolrow, focus=False):
 
262
    def rows(self, (maxcol,), focus=False):
263
263
        """How many rows this widget will occupy might depend on
264
264
        whether we have focus or not.
265
265
        This overrides the method from urwid.FlowWidget"""
266
 
        return self.current_widget(focus).rows(maxcolrow, focus=focus)
 
266
        return self.current_widget(focus).rows((maxcol,), focus=focus)
267
267
    
268
268
    def current_widget(self, focus=False):
269
269
        if focus or self.opened:
273
273
    def update(self):
274
274
        "Called when what is visible on the screen should be updated."
275
275
        # 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",
 
276
        with_standout = { u"normal": u"standout",
 
277
                          u"bold": u"bold-standout",
 
278
                          u"underline-blink":
 
279
                              u"underline-blink-standout",
 
280
                          u"bold-underline-blink":
 
281
                              u"bold-underline-blink-standout",
282
282
                          }
283
283
 
284
284
        # Rebuild focus and non-focus widgets using current properties
285
285
 
286
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"]:
 
287
        base = (u'%(name)s: '
 
288
                      % {u"name": self.properties[u"Name"]})
 
289
        if not self.properties[u"Enabled"]:
 
290
            message = u"DISABLED"
 
291
        elif self.properties[u"ApprovalPending"]:
292
292
            timeout = datetime.timedelta(milliseconds
293
293
                                         = self.properties
294
 
                                         ["ApprovalDelay"])
 
294
                                         [u"ApprovalDelay"])
295
295
            last_approval_request = isoformat_to_datetime(
296
 
                self.properties["LastApprovalRequest"])
 
296
                self.properties[u"LastApprovalRequest"])
297
297
            if last_approval_request is not None:
298
298
                timer = timeout - (datetime.datetime.utcnow()
299
299
                                   - last_approval_request)
300
300
            else:
301
301
                timer = datetime.timedelta()
302
 
            if self.properties["ApprovedByDefault"]:
303
 
                message = "Approval in %s. (d)eny?"
 
302
            if self.properties[u"ApprovedByDefault"]:
 
303
                message = u"Approval in %s. (d)eny?"
304
304
            else:
305
 
                message = "Denial in %s. (a)pprove?"
 
305
                message = u"Denial in %s. (a)pprove?"
306
306
            message = message % unicode(timer).rsplit(".", 1)[0]
307
307
        elif self.last_checker_failed:
308
308
            timeout = datetime.timedelta(milliseconds
309
309
                                         = self.properties
310
 
                                         ["Timeout"])
 
310
                                         [u"Timeout"])
311
311
            last_ok = isoformat_to_datetime(
312
 
                max((self.properties["LastCheckedOK"]
313
 
                     or self.properties["Created"]),
314
 
                    self.properties["LastEnabled"]))
 
312
                max((self.properties[u"LastCheckedOK"]
 
313
                     or self.properties[u"Created"]),
 
314
                    self.properties[u"LastEnabled"]))
315
315
            timer = timeout - (datetime.datetime.utcnow() - last_ok)
316
 
            message = ('A checker has failed! Time until client'
317
 
                       ' gets disabled: %s'
 
316
            message = (u'A checker has failed! Time until client'
 
317
                       u' gets disabled: %s'
318
318
                           % unicode(timer).rsplit(".", 1)[0])
319
319
        else:
320
 
            message = "enabled"
 
320
            message = u"enabled"
321
321
        self._text = "%s%s" % (base, message)
322
322
            
323
323
        if not urwid.supports_unicode():
324
324
            self._text = self._text.encode("ascii", "replace")
325
 
        textlist = [("normal", self._text)]
 
325
        textlist = [(u"normal", self._text)]
326
326
        self._text_widget.set_text(textlist)
327
327
        self._focus_text_widget.set_text([(with_standout[text[0]],
328
328
                                           text[1])
348
348
        if self.delete_hook is not None:
349
349
            self.delete_hook(self)
350
350
    
351
 
    def render(self, maxcolrow, focus=False):
 
351
    def render(self, (maxcol,), focus=False):
352
352
        """Render differently if we have focus.
353
353
        This overrides the method from urwid.FlowWidget"""
354
 
        return self.current_widget(focus).render(maxcolrow,
 
354
        return self.current_widget(focus).render((maxcol,),
355
355
                                                 focus=focus)
356
356
    
357
 
    def keypress(self, maxcolrow, key):
 
357
    def keypress(self, (maxcol,), key):
358
358
        """Handle keys.
359
359
        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":
 
360
        if key == u"+":
 
361
            self.proxy.Enable(dbus_interface = client_interface)
 
362
        elif key == u"-":
 
363
            self.proxy.Disable(dbus_interface = client_interface)
 
364
        elif key == u"a":
367
365
            self.proxy.Approve(dbus.Boolean(True, variant_level=1),
368
 
                               dbus_interface = client_interface,
369
 
                               ignore_reply=True)
370
 
        elif key == "d":
 
366
                               dbus_interface = client_interface)
 
367
        elif key == u"d":
371
368
            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":
 
369
                                  dbus_interface = client_interface)
 
370
        elif key == u"R" or key == u"_" or key == u"ctrl k":
375
371
            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)
 
372
                                                  .object_path)
 
373
        elif key == u"s":
 
374
            self.proxy.StartChecker(dbus_interface = client_interface)
 
375
        elif key == u"S":
 
376
            self.proxy.StopChecker(dbus_interface = client_interface)
 
377
        elif key == u"C":
 
378
            self.proxy.CheckedOK(dbus_interface = client_interface)
387
379
        # xxx
388
 
#         elif key == "p" or key == "=":
 
380
#         elif key == u"p" or key == "=":
389
381
#             self.proxy.pause()
390
 
#         elif key == "u" or key == ":":
 
382
#         elif key == u"u" or key == ":":
391
383
#             self.proxy.unpause()
392
 
#         elif key == "RET":
 
384
#         elif key == u"RET":
393
385
#             self.open()
394
386
        else:
395
387
            return key
411
403
    "down" key presses, thus not allowing any containing widgets to
412
404
    use them as an excuse to shift focus away from this widget.
413
405
    """
414
 
    def keypress(self, maxcolrow, key):
415
 
        ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)
416
 
        if ret in ("up", "down"):
 
406
    def keypress(self, (maxcol, maxrow), key):
 
407
        ret = super(ConstrainedListBox, self).keypress((maxcol,
 
408
                                                        maxrow), key)
 
409
        if ret in (u"up", u"down"):
417
410
            return
418
411
        return ret
419
412
 
428
421
        self.screen = urwid.curses_display.Screen()
429
422
        
430
423
        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")),
 
424
                (u"normal",
 
425
                 u"default", u"default", None),
 
426
                (u"bold",
 
427
                 u"default", u"default", u"bold"),
 
428
                (u"underline-blink",
 
429
                 u"default", u"default", u"underline"),
 
430
                (u"standout",
 
431
                 u"default", u"default", u"standout"),
 
432
                (u"bold-underline-blink",
 
433
                 u"default", u"default", (u"bold", u"underline")),
 
434
                (u"bold-standout",
 
435
                 u"default", u"default", (u"bold", u"standout")),
 
436
                (u"underline-blink-standout",
 
437
                 u"default", u"default", (u"underline", u"standout")),
 
438
                (u"bold-underline-blink-standout",
 
439
                 u"default", u"default", (u"bold", u"underline",
 
440
                                          u"standout")),
448
441
                ))
449
442
        
450
443
        if urwid.supports_unicode():
451
 
            self.divider = "─" # \u2500
452
 
            #self.divider = "━" # \u2501
 
444
            self.divider = u"─" # \u2500
 
445
            #self.divider = u"━" # \u2501
453
446
        else:
454
 
            #self.divider = "-" # \u002d
455
 
            self.divider = "_" # \u005f
 
447
            #self.divider = u"-" # \u002d
 
448
            self.divider = u"_" # \u005f
456
449
        
457
450
        self.screen.start()
458
451
        
472
465
        # This keeps track of whether self.uilist currently has
473
466
        # self.logbox in it or not
474
467
        self.log_visible = True
475
 
        self.log_wrap = "any"
 
468
        self.log_wrap = u"any"
476
469
        
477
470
        self.rebuild()
478
 
        self.log_message_raw(("bold",
479
 
                              "Mandos Monitor version " + version))
480
 
        self.log_message_raw(("bold",
481
 
                              "q: Quit  ?: Help"))
 
471
        self.log_message_raw((u"bold",
 
472
                              u"Mandos Monitor version " + version))
 
473
        self.log_message_raw((u"bold",
 
474
                              u"q: Quit  ?: Help"))
482
475
        
483
476
        self.busname = domain + '.Mandos'
484
477
        self.main_loop = gobject.MainLoop()
485
478
        self.bus = dbus.SystemBus()
486
479
        mandos_dbus_objc = self.bus.get_object(
487
 
            self.busname, "/", follow_name_owner_changes=True)
 
480
            self.busname, u"/", follow_name_owner_changes=True)
488
481
        self.mandos_serv = dbus.Interface(mandos_dbus_objc,
489
482
                                          dbus_interface
490
483
                                          = server_interface)
495
488
            mandos_clients = dbus.Dictionary()
496
489
        
497
490
        (self.mandos_serv
498
 
         .connect_to_signal("ClientRemoved",
 
491
         .connect_to_signal(u"ClientRemoved",
499
492
                            self.find_and_remove_client,
500
493
                            dbus_interface=server_interface,
501
494
                            byte_arrays=True))
502
495
        (self.mandos_serv
503
 
         .connect_to_signal("ClientAdded",
 
496
         .connect_to_signal(u"ClientAdded",
504
497
                            self.add_new_client,
505
498
                            dbus_interface=server_interface,
506
499
                            byte_arrays=True))
507
500
        (self.mandos_serv
508
 
         .connect_to_signal("ClientNotFound",
 
501
         .connect_to_signal(u"ClientNotFound",
509
502
                            self.client_not_found,
510
503
                            dbus_interface=server_interface,
511
504
                            byte_arrays=True))
526
519
                            path=path)
527
520
    
528
521
    def client_not_found(self, fingerprint, address):
529
 
        self.log_message(("Client with address %s and fingerprint %s"
530
 
                          " could not be found" % (address,
 
522
        self.log_message((u"Client with address %s and fingerprint %s"
 
523
                          u" could not be found" % (address,
531
524
                                                    fingerprint)))
532
525
    
533
526
    def rebuild(self):
549
542
    
550
543
    def log_message(self, message):
551
544
        timestamp = datetime.datetime.now().isoformat()
552
 
        self.log_message_raw(timestamp + ": " + message)
 
545
        self.log_message_raw(timestamp + u": " + message)
553
546
    
554
547
    def log_message_raw(self, markup):
555
548
        """Add a log message to the log buffer."""
558
551
            and len(self.log) > self.max_log_length):
559
552
            del self.log[0:len(self.log)-self.max_log_length-1]
560
553
        self.logbox.set_focus(len(self.logbox.body.contents),
561
 
                              coming_from="above")
 
554
                              coming_from=u"above")
562
555
        self.refresh()
563
556
    
564
557
    def toggle_log_display(self):
565
558
        """Toggle visibility of the log buffer."""
566
559
        self.log_visible = not self.log_visible
567
560
        self.rebuild()
568
 
        #self.log_message("Log visibility changed to: "
 
561
        #self.log_message(u"Log visibility changed to: "
569
562
        #                 + unicode(self.log_visible))
570
563
    
571
564
    def change_log_display(self):
572
565
        """Change type of log display.
573
566
        Currently, this toggles wrapping of text lines."""
574
 
        if self.log_wrap == "clip":
575
 
            self.log_wrap = "any"
 
567
        if self.log_wrap == u"clip":
 
568
            self.log_wrap = u"any"
576
569
        else:
577
 
            self.log_wrap = "clip"
 
570
            self.log_wrap = u"clip"
578
571
        for textwidget in self.log:
579
572
            textwidget.set_wrap_mode(self.log_wrap)
580
 
        #self.log_message("Wrap mode: " + self.log_wrap)
 
573
        #self.log_message(u"Wrap mode: " + self.log_wrap)
581
574
    
582
575
    def find_and_remove_client(self, path, name):
583
576
        """Find an client from its object path and remove it.
610
603
        if path is None:
611
604
            path = client.proxy.object_path
612
605
        self.clients_dict[path] = client
613
 
        self.clients.sort(None, lambda c: c.properties["Name"])
 
606
        self.clients.sort(None, lambda c: c.properties[u"Name"])
614
607
        self.refresh()
615
608
    
616
609
    def remove_client(self, client, path=None):
647
640
    
648
641
    def process_input(self, source, condition):
649
642
        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
 
643
        translations = { u"ctrl n": u"down",      # Emacs
 
644
                         u"ctrl p": u"up",        # Emacs
 
645
                         u"ctrl v": u"page down", # Emacs
 
646
                         u"meta v": u"page up",   # Emacs
 
647
                         u" ": u"page down",      # less
 
648
                         u"f": u"page down",      # less
 
649
                         u"b": u"page up",        # less
 
650
                         u"j": u"down",           # vi
 
651
                         u"k": u"up",             # vi
659
652
                         }
660
653
        for key in keys:
661
654
            try:
663
656
            except KeyError:    # :-)
664
657
                pass
665
658
            
666
 
            if key == "q" or key == "Q":
 
659
            if key == u"q" or key == u"Q":
667
660
                self.stop()
668
661
                break
669
 
            elif key == "window resize":
 
662
            elif key == u"window resize":
670
663
                self.size = self.screen.get_cols_rows()
671
664
                self.refresh()
672
 
            elif key == "\f":  # Ctrl-L
 
665
            elif key == u"\f":  # Ctrl-L
673
666
                self.refresh()
674
 
            elif key == "l" or key == "D":
 
667
            elif key == u"l" or key == u"D":
675
668
                self.toggle_log_display()
676
669
                self.refresh()
677
 
            elif key == "w" or key == "i":
 
670
            elif key == u"w" or key == u"i":
678
671
                self.change_log_display()
679
672
                self.refresh()
680
 
            elif key == "?" or key == "f1" or key == "esc":
 
673
            elif key == u"?" or key == u"f1" or key == u"esc":
681
674
                if not self.log_visible:
682
675
                    self.log_visible = True
683
676
                    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"))))
 
677
                self.log_message_raw((u"bold",
 
678
                                      u"  ".
 
679
                                      join((u"q: Quit",
 
680
                                            u"?: Help",
 
681
                                            u"l: Log window toggle",
 
682
                                            u"TAB: Switch window",
 
683
                                            u"w: Wrap (log)"))))
 
684
                self.log_message_raw((u"bold",
 
685
                                      u"  "
 
686
                                      .join((u"Clients:",
 
687
                                             u"+: Enable",
 
688
                                             u"-: Disable",
 
689
                                             u"R: Remove",
 
690
                                             u"s: Start new checker",
 
691
                                             u"S: Stop checker",
 
692
                                             u"C: Checker OK",
 
693
                                             u"a: Approve",
 
694
                                             u"d: Deny"))))
702
695
                self.refresh()
703
 
            elif key == "tab":
 
696
            elif key == u"tab":
704
697
                if self.topwidget.get_focus() is self.logbox:
705
698
                    self.topwidget.set_focus(0)
706
699
                else:
707
700
                    self.topwidget.set_focus(self.logbox)
708
701
                self.refresh()
709
 
            #elif (key == "end" or key == "meta >" or key == "G"
710
 
            #      or key == ">"):
 
702
            #elif (key == u"end" or key == u"meta >" or key == u"G"
 
703
            #      or key == u">"):
711
704
            #    pass            # xxx end-of-buffer
712
 
            #elif (key == "home" or key == "meta <" or key == "g"
713
 
            #      or key == "<"):
 
705
            #elif (key == u"home" or key == u"meta <" or key == u"g"
 
706
            #      or key == u"<"):
714
707
            #    pass            # xxx beginning-of-buffer
715
 
            #elif key == "ctrl e" or key == "$":
 
708
            #elif key == u"ctrl e" or key == u"$":
716
709
            #    pass            # xxx move-end-of-line
717
 
            #elif key == "ctrl a" or key == "^":
 
710
            #elif key == u"ctrl a" or key == u"^":
718
711
            #    pass            # xxx move-beginning-of-line
719
 
            #elif key == "ctrl b" or key == "meta (" or key == "h":
 
712
            #elif key == u"ctrl b" or key == u"meta (" or key == u"h":
720
713
            #    pass            # xxx left
721
 
            #elif key == "ctrl f" or key == "meta )" or key == "l":
 
714
            #elif key == u"ctrl f" or key == u"meta )" or key == u"l":
722
715
            #    pass            # xxx right
723
 
            #elif key == "a":
 
716
            #elif key == u"a":
724
717
            #    pass            # scroll up log
725
 
            #elif key == "z":
 
718
            #elif key == u"z":
726
719
            #    pass            # scroll down log
727
720
            elif self.topwidget.selectable():
728
721
                self.topwidget.keypress(self.size, key)