/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.2.3"
 
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 == "+":
 
360
        if key == u"+":
361
361
            self.proxy.Enable(dbus_interface = client_interface)
362
 
        elif key == "-":
 
362
        elif key == u"-":
363
363
            self.proxy.Disable(dbus_interface = client_interface)
364
 
        elif key == "a":
 
364
        elif key == u"a":
365
365
            self.proxy.Approve(dbus.Boolean(True, variant_level=1),
366
366
                               dbus_interface = client_interface)
367
 
        elif key == "d":
 
367
        elif key == u"d":
368
368
            self.proxy.Approve(dbus.Boolean(False, variant_level=1),
369
369
                                  dbus_interface = client_interface)
370
 
        elif key == "R" or key == "_" or key == "ctrl k":
 
370
        elif key == u"R" or key == u"_" or key == u"ctrl k":
371
371
            self.server_proxy_object.RemoveClient(self.proxy
372
372
                                                  .object_path)
373
 
        elif key == "s":
 
373
        elif key == u"s":
374
374
            self.proxy.StartChecker(dbus_interface = client_interface)
375
 
        elif key == "S":
 
375
        elif key == u"S":
376
376
            self.proxy.StopChecker(dbus_interface = client_interface)
377
 
        elif key == "C":
 
377
        elif key == u"C":
378
378
            self.proxy.CheckedOK(dbus_interface = client_interface)
379
379
        # xxx
380
 
#         elif key == "p" or key == "=":
 
380
#         elif key == u"p" or key == "=":
381
381
#             self.proxy.pause()
382
 
#         elif key == "u" or key == ":":
 
382
#         elif key == u"u" or key == ":":
383
383
#             self.proxy.unpause()
384
 
#         elif key == "RET":
 
384
#         elif key == u"RET":
385
385
#             self.open()
386
386
        else:
387
387
            return key
403
403
    "down" key presses, thus not allowing any containing widgets to
404
404
    use them as an excuse to shift focus away from this widget.
405
405
    """
406
 
    def keypress(self, maxcolrow, key):
407
 
        ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)
408
 
        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"):
409
410
            return
410
411
        return ret
411
412
 
420
421
        self.screen = urwid.curses_display.Screen()
421
422
        
422
423
        self.screen.register_palette((
423
 
                ("normal",
424
 
                 "default", "default", None),
425
 
                ("bold",
426
 
                 "default", "default", "bold"),
427
 
                ("underline-blink",
428
 
                 "default", "default", "underline"),
429
 
                ("standout",
430
 
                 "default", "default", "standout"),
431
 
                ("bold-underline-blink",
432
 
                 "default", "default", ("bold", "underline")),
433
 
                ("bold-standout",
434
 
                 "default", "default", ("bold", "standout")),
435
 
                ("underline-blink-standout",
436
 
                 "default", "default", ("underline", "standout")),
437
 
                ("bold-underline-blink-standout",
438
 
                 "default", "default", ("bold", "underline",
439
 
                                          "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")),
440
441
                ))
441
442
        
442
443
        if urwid.supports_unicode():
443
 
            self.divider = "─" # \u2500
444
 
            #self.divider = "━" # \u2501
 
444
            self.divider = u"─" # \u2500
 
445
            #self.divider = u"━" # \u2501
445
446
        else:
446
 
            #self.divider = "-" # \u002d
447
 
            self.divider = "_" # \u005f
 
447
            #self.divider = u"-" # \u002d
 
448
            self.divider = u"_" # \u005f
448
449
        
449
450
        self.screen.start()
450
451
        
464
465
        # This keeps track of whether self.uilist currently has
465
466
        # self.logbox in it or not
466
467
        self.log_visible = True
467
 
        self.log_wrap = "any"
 
468
        self.log_wrap = u"any"
468
469
        
469
470
        self.rebuild()
470
 
        self.log_message_raw(("bold",
471
 
                              "Mandos Monitor version " + version))
472
 
        self.log_message_raw(("bold",
473
 
                              "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"))
474
475
        
475
476
        self.busname = domain + '.Mandos'
476
477
        self.main_loop = gobject.MainLoop()
477
478
        self.bus = dbus.SystemBus()
478
479
        mandos_dbus_objc = self.bus.get_object(
479
 
            self.busname, "/", follow_name_owner_changes=True)
 
480
            self.busname, u"/", follow_name_owner_changes=True)
480
481
        self.mandos_serv = dbus.Interface(mandos_dbus_objc,
481
482
                                          dbus_interface
482
483
                                          = server_interface)
487
488
            mandos_clients = dbus.Dictionary()
488
489
        
489
490
        (self.mandos_serv
490
 
         .connect_to_signal("ClientRemoved",
 
491
         .connect_to_signal(u"ClientRemoved",
491
492
                            self.find_and_remove_client,
492
493
                            dbus_interface=server_interface,
493
494
                            byte_arrays=True))
494
495
        (self.mandos_serv
495
 
         .connect_to_signal("ClientAdded",
 
496
         .connect_to_signal(u"ClientAdded",
496
497
                            self.add_new_client,
497
498
                            dbus_interface=server_interface,
498
499
                            byte_arrays=True))
499
500
        (self.mandos_serv
500
 
         .connect_to_signal("ClientNotFound",
 
501
         .connect_to_signal(u"ClientNotFound",
501
502
                            self.client_not_found,
502
503
                            dbus_interface=server_interface,
503
504
                            byte_arrays=True))
518
519
                            path=path)
519
520
    
520
521
    def client_not_found(self, fingerprint, address):
521
 
        self.log_message(("Client with address %s and fingerprint %s"
522
 
                          " could not be found" % (address,
 
522
        self.log_message((u"Client with address %s and fingerprint %s"
 
523
                          u" could not be found" % (address,
523
524
                                                    fingerprint)))
524
525
    
525
526
    def rebuild(self):
541
542
    
542
543
    def log_message(self, message):
543
544
        timestamp = datetime.datetime.now().isoformat()
544
 
        self.log_message_raw(timestamp + ": " + message)
 
545
        self.log_message_raw(timestamp + u": " + message)
545
546
    
546
547
    def log_message_raw(self, markup):
547
548
        """Add a log message to the log buffer."""
550
551
            and len(self.log) > self.max_log_length):
551
552
            del self.log[0:len(self.log)-self.max_log_length-1]
552
553
        self.logbox.set_focus(len(self.logbox.body.contents),
553
 
                              coming_from="above")
 
554
                              coming_from=u"above")
554
555
        self.refresh()
555
556
    
556
557
    def toggle_log_display(self):
557
558
        """Toggle visibility of the log buffer."""
558
559
        self.log_visible = not self.log_visible
559
560
        self.rebuild()
560
 
        #self.log_message("Log visibility changed to: "
 
561
        #self.log_message(u"Log visibility changed to: "
561
562
        #                 + unicode(self.log_visible))
562
563
    
563
564
    def change_log_display(self):
564
565
        """Change type of log display.
565
566
        Currently, this toggles wrapping of text lines."""
566
 
        if self.log_wrap == "clip":
567
 
            self.log_wrap = "any"
 
567
        if self.log_wrap == u"clip":
 
568
            self.log_wrap = u"any"
568
569
        else:
569
 
            self.log_wrap = "clip"
 
570
            self.log_wrap = u"clip"
570
571
        for textwidget in self.log:
571
572
            textwidget.set_wrap_mode(self.log_wrap)
572
 
        #self.log_message("Wrap mode: " + self.log_wrap)
 
573
        #self.log_message(u"Wrap mode: " + self.log_wrap)
573
574
    
574
575
    def find_and_remove_client(self, path, name):
575
576
        """Find an client from its object path and remove it.
602
603
        if path is None:
603
604
            path = client.proxy.object_path
604
605
        self.clients_dict[path] = client
605
 
        self.clients.sort(None, lambda c: c.properties["Name"])
 
606
        self.clients.sort(None, lambda c: c.properties[u"Name"])
606
607
        self.refresh()
607
608
    
608
609
    def remove_client(self, client, path=None):
639
640
    
640
641
    def process_input(self, source, condition):
641
642
        keys = self.screen.get_input()
642
 
        translations = { "ctrl n": "down",      # Emacs
643
 
                         "ctrl p": "up",        # Emacs
644
 
                         "ctrl v": "page down", # Emacs
645
 
                         "meta v": "page up",   # Emacs
646
 
                         " ": "page down",      # less
647
 
                         "f": "page down",      # less
648
 
                         "b": "page up",        # less
649
 
                         "j": "down",           # vi
650
 
                         "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
651
652
                         }
652
653
        for key in keys:
653
654
            try:
655
656
            except KeyError:    # :-)
656
657
                pass
657
658
            
658
 
            if key == "q" or key == "Q":
 
659
            if key == u"q" or key == u"Q":
659
660
                self.stop()
660
661
                break
661
 
            elif key == "window resize":
 
662
            elif key == u"window resize":
662
663
                self.size = self.screen.get_cols_rows()
663
664
                self.refresh()
664
 
            elif key == "\f":  # Ctrl-L
 
665
            elif key == u"\f":  # Ctrl-L
665
666
                self.refresh()
666
 
            elif key == "l" or key == "D":
 
667
            elif key == u"l" or key == u"D":
667
668
                self.toggle_log_display()
668
669
                self.refresh()
669
 
            elif key == "w" or key == "i":
 
670
            elif key == u"w" or key == u"i":
670
671
                self.change_log_display()
671
672
                self.refresh()
672
 
            elif key == "?" or key == "f1" or key == "esc":
 
673
            elif key == u"?" or key == u"f1" or key == u"esc":
673
674
                if not self.log_visible:
674
675
                    self.log_visible = True
675
676
                    self.rebuild()
676
 
                self.log_message_raw(("bold",
677
 
                                      "  ".
678
 
                                      join(("q: Quit",
679
 
                                            "?: Help",
680
 
                                            "l: Log window toggle",
681
 
                                            "TAB: Switch window",
682
 
                                            "w: Wrap (log)"))))
683
 
                self.log_message_raw(("bold",
684
 
                                      "  "
685
 
                                      .join(("Clients:",
686
 
                                             "+: Enable",
687
 
                                             "-: Disable",
688
 
                                             "R: Remove",
689
 
                                             "s: Start new checker",
690
 
                                             "S: Stop checker",
691
 
                                             "C: Checker OK",
692
 
                                             "a: Approve",
693
 
                                             "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"))))
694
695
                self.refresh()
695
 
            elif key == "tab":
 
696
            elif key == u"tab":
696
697
                if self.topwidget.get_focus() is self.logbox:
697
698
                    self.topwidget.set_focus(0)
698
699
                else:
699
700
                    self.topwidget.set_focus(self.logbox)
700
701
                self.refresh()
701
 
            #elif (key == "end" or key == "meta >" or key == "G"
702
 
            #      or key == ">"):
 
702
            #elif (key == u"end" or key == u"meta >" or key == u"G"
 
703
            #      or key == u">"):
703
704
            #    pass            # xxx end-of-buffer
704
 
            #elif (key == "home" or key == "meta <" or key == "g"
705
 
            #      or key == "<"):
 
705
            #elif (key == u"home" or key == u"meta <" or key == u"g"
 
706
            #      or key == u"<"):
706
707
            #    pass            # xxx beginning-of-buffer
707
 
            #elif key == "ctrl e" or key == "$":
 
708
            #elif key == u"ctrl e" or key == u"$":
708
709
            #    pass            # xxx move-end-of-line
709
 
            #elif key == "ctrl a" or key == "^":
 
710
            #elif key == u"ctrl a" or key == u"^":
710
711
            #    pass            # xxx move-beginning-of-line
711
 
            #elif key == "ctrl b" or key == "meta (" or key == "h":
 
712
            #elif key == u"ctrl b" or key == u"meta (" or key == u"h":
712
713
            #    pass            # xxx left
713
 
            #elif key == "ctrl f" or key == "meta )" or key == "l":
 
714
            #elif key == u"ctrl f" or key == u"meta )" or key == u"l":
714
715
            #    pass            # xxx right
715
 
            #elif key == "a":
 
716
            #elif key == u"a":
716
717
            #    pass            # scroll up log
717
 
            #elif key == "z":
 
718
            #elif key == u"z":
718
719
            #    pass            # scroll down log
719
720
            elif self.topwidget.selectable():
720
721
                self.topwidget.keypress(self.size, key)