/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-09-15 17:21:04 UTC
  • Revision ID: teddy@fukt.bsnet.se-20100915172104-eopud55s7dc6vkfj
* plugins.d/usplash.c (main): BUG FIX: allocate space for the final
                              NULL in cmdline_argv.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-monitor
 
1
#!/usr/bin/python
 
2
# -*- mode: python; coding: utf-8 -*-
 
3
 
 
4
from __future__ import division, absolute_import, with_statement
 
5
 
 
6
import sys
 
7
import os
 
8
import signal
 
9
 
 
10
import datetime
 
11
 
 
12
import urwid.curses_display
 
13
import urwid
 
14
 
 
15
from dbus.mainloop.glib import DBusGMainLoop
 
16
import gobject
 
17
 
 
18
import dbus
 
19
 
 
20
import UserList
 
21
 
 
22
import locale
 
23
 
 
24
locale.setlocale(locale.LC_ALL, u'')
 
25
 
 
26
import logging
 
27
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
 
28
 
 
29
# Some useful constants
 
30
domain = 'se.bsnet.fukt'
 
31
server_interface = domain + '.Mandos'
 
32
client_interface = domain + '.Mandos.Client'
 
33
version = "1.0.15"
 
34
 
 
35
# Always run in monochrome mode
 
36
urwid.curses_display.curses.has_colors = lambda : False
 
37
 
 
38
# Urwid doesn't support blinking, but we want it.  Since we have no
 
39
# use for underline on its own, we make underline also always blink.
 
40
urwid.curses_display.curses.A_UNDERLINE |= (
 
41
    urwid.curses_display.curses.A_BLINK)
 
42
 
 
43
def isoformat_to_datetime(iso):
 
44
    "Parse an ISO 8601 date string to a datetime.datetime()"
 
45
    if not iso:
 
46
        return None
 
47
    d, t = iso.split(u"T", 1)
 
48
    year, month, day = d.split(u"-", 2)
 
49
    hour, minute, second = t.split(u":", 2)
 
50
    second, fraction = divmod(float(second), 1)
 
51
    return datetime.datetime(int(year),
 
52
                             int(month),
 
53
                             int(day),
 
54
                             int(hour),
 
55
                             int(minute),
 
56
                             int(second),           # Whole seconds
 
57
                             int(fraction*1000000)) # Microseconds
 
58
 
 
59
class MandosClientPropertyCache(object):
 
60
    """This wraps a Mandos Client D-Bus proxy object, caches the
 
61
    properties and calls a hook function when any of them are
 
62
    changed.
 
63
    """
 
64
    def __init__(self, proxy_object=None, *args, **kwargs):
 
65
        self.proxy = proxy_object # Mandos Client proxy object
 
66
        
 
67
        self.properties = dict()
 
68
        self.proxy.connect_to_signal(u"PropertyChanged",
 
69
                                     self.property_changed,
 
70
                                     client_interface,
 
71
                                     byte_arrays=True)
 
72
        
 
73
        self.properties.update(
 
74
            self.proxy.GetAll(client_interface,
 
75
                              dbus_interface = dbus.PROPERTIES_IFACE))
 
76
 
 
77
        #XXX This break good super behaviour!
 
78
#        super(MandosClientPropertyCache, self).__init__(
 
79
#            *args, **kwargs)
 
80
    
 
81
    def property_changed(self, property=None, value=None):
 
82
        """This is called whenever we get a PropertyChanged signal
 
83
        It updates the changed property in the "properties" dict.
 
84
        """
 
85
        # Update properties dict with new value
 
86
        self.properties[property] = value
 
87
 
 
88
 
 
89
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
 
90
    """A Mandos Client which is visible on the screen.
 
91
    """
 
92
    
 
93
    def __init__(self, server_proxy_object=None, update_hook=None,
 
94
                 delete_hook=None, logger=None, *args, **kwargs):
 
95
        # Called on update
 
96
        self.update_hook = update_hook
 
97
        # Called on delete
 
98
        self.delete_hook = delete_hook
 
99
        # Mandos Server proxy object
 
100
        self.server_proxy_object = server_proxy_object
 
101
        # Logger
 
102
        self.logger = logger
 
103
        
 
104
        self._update_timer_callback_tag = None
 
105
        self.last_checker_failed = False
 
106
        
 
107
        # The widget shown normally
 
108
        self._text_widget = urwid.Text(u"")
 
109
        # The widget shown when we have focus
 
110
        self._focus_text_widget = urwid.Text(u"")
 
111
        super(MandosClientWidget, self).__init__(
 
112
            update_hook=update_hook, delete_hook=delete_hook,
 
113
            *args, **kwargs)
 
114
        self.update()
 
115
        self.opened = False
 
116
        self.proxy.connect_to_signal(u"CheckerCompleted",
 
117
                                     self.checker_completed,
 
118
                                     client_interface,
 
119
                                     byte_arrays=True)
 
120
        self.proxy.connect_to_signal(u"CheckerStarted",
 
121
                                     self.checker_started,
 
122
                                     client_interface,
 
123
                                     byte_arrays=True)
 
124
        self.proxy.connect_to_signal(u"GotSecret",
 
125
                                     self.got_secret,
 
126
                                     client_interface,
 
127
                                     byte_arrays=True)
 
128
        self.proxy.connect_to_signal(u"NeedApproval",
 
129
                                     self.need_approval,
 
130
                                     client_interface,
 
131
                                     byte_arrays=True)
 
132
        self.proxy.connect_to_signal(u"Rejected",
 
133
                                     self.rejected,
 
134
                                     client_interface,
 
135
                                     byte_arrays=True)
 
136
        last_checked_ok = isoformat_to_datetime(self.properties
 
137
                                                [u"LastCheckedOK"])
 
138
        if last_checked_ok is None:
 
139
            self.last_checker_failed = True
 
140
        else:
 
141
            self.last_checker_failed = ((datetime.datetime.utcnow()
 
142
                                         - last_checked_ok)
 
143
                                        > datetime.timedelta
 
144
                                        (milliseconds=
 
145
                                         self.properties
 
146
                                         [u"Interval"]))
 
147
        if self.last_checker_failed:
 
148
            self._update_timer_callback_tag = (gobject.timeout_add
 
149
                                               (1000,
 
150
                                                self.update_timer))
 
151
    
 
152
    def checker_completed(self, exitstatus, condition, command):
 
153
        if exitstatus == 0:
 
154
            if self.last_checker_failed:
 
155
                self.last_checker_failed = False
 
156
                gobject.source_remove(self._update_timer_callback_tag)
 
157
                self._update_timer_callback_tag = None
 
158
            #self.logger(u'Checker for client %s (command "%s")'
 
159
            #            u' was successful'
 
160
            #            % (self.properties[u"Name"], command))
 
161
            self.update()
 
162
            return
 
163
        # Checker failed
 
164
        if not self.last_checker_failed:
 
165
            self.last_checker_failed = True
 
166
            self._update_timer_callback_tag = (gobject.timeout_add
 
167
                                               (1000,
 
168
                                                self.update_timer))
 
169
        if os.WIFEXITED(condition):
 
170
            self.logger(u'Checker for client %s (command "%s")'
 
171
                        u' failed with exit code %s'
 
172
                        % (self.properties[u"Name"], command,
 
173
                           os.WEXITSTATUS(condition)))
 
174
        elif os.WIFSIGNALED(condition):
 
175
            self.logger(u'Checker for client %s (command "%s")'
 
176
                        u' was killed by signal %s'
 
177
                        % (self.properties[u"Name"], command,
 
178
                           os.WTERMSIG(condition)))
 
179
        elif os.WCOREDUMP(condition):
 
180
            self.logger(u'Checker for client %s (command "%s")'
 
181
                        u' dumped core'
 
182
                        % (self.properties[u"Name"], command))
 
183
        else:
 
184
            self.logger(u'Checker for client %s completed'
 
185
                        u' mysteriously')
 
186
        self.update()
 
187
    
 
188
    def checker_started(self, command):
 
189
        #self.logger(u'Client %s started checker "%s"'
 
190
        #            % (self.properties[u"Name"], unicode(command)))
 
191
        pass
 
192
    
 
193
    def got_secret(self):
 
194
        self.last_checker_failed = False
 
195
        self.logger(u'Client %s received its secret'
 
196
                    % self.properties[u"Name"])
 
197
    
 
198
    def need_approval(self, timeout, default):
 
199
        if not default:
 
200
            message = u'Client %s needs approval within %s seconds'
 
201
        else:
 
202
            message = u'Client %s will get its secret in %s seconds'
 
203
        self.logger(message
 
204
                    % (self.properties[u"Name"], timeout/1000))
 
205
    
 
206
    def rejected(self, reason):
 
207
        self.logger(u'Client %s was rejected; reason: %s'
 
208
                    % (self.properties[u"Name"], reason))
 
209
    
 
210
    def selectable(self):
 
211
        """Make this a "selectable" widget.
 
212
        This overrides the method from urwid.FlowWidget."""
 
213
        return True
 
214
    
 
215
    def rows(self, (maxcol,), focus=False):
 
216
        """How many rows this widget will occupy might depend on
 
217
        whether we have focus or not.
 
218
        This overrides the method from urwid.FlowWidget"""
 
219
        return self.current_widget(focus).rows((maxcol,), focus=focus)
 
220
    
 
221
    def current_widget(self, focus=False):
 
222
        if focus or self.opened:
 
223
            return self._focus_widget
 
224
        return self._widget
 
225
    
 
226
    def update(self):
 
227
        "Called when what is visible on the screen should be updated."
 
228
        # How to add standout mode to a style
 
229
        with_standout = { u"normal": u"standout",
 
230
                          u"bold": u"bold-standout",
 
231
                          u"underline-blink":
 
232
                              u"underline-blink-standout",
 
233
                          u"bold-underline-blink":
 
234
                              u"bold-underline-blink-standout",
 
235
                          }
 
236
 
 
237
        # Rebuild focus and non-focus widgets using current properties
 
238
 
 
239
        # Base part of a client. Name!
 
240
        base = (u'%(name)s: '
 
241
                      % {u"name": self.properties[u"Name"]})
 
242
        if not self.properties[u"Enabled"]:
 
243
            message = u"DISABLED"
 
244
        elif self.properties[u"ApprovalPending"]:
 
245
            if self.properties[u"ApprovedByDefault"]:
 
246
                message = u"Connection established to client. (d)eny?"
 
247
            else:
 
248
                message = u"Seeks approval to send secret. (a)pprove?"
 
249
        elif self.last_checker_failed:
 
250
            timeout = datetime.timedelta(milliseconds
 
251
                                         = self.properties
 
252
                                         [u"Timeout"])
 
253
            last_ok = isoformat_to_datetime(
 
254
                max((self.properties[u"LastCheckedOK"]
 
255
                     or self.properties[u"Created"]),
 
256
                    self.properties[u"LastEnabled"]))
 
257
            timer = timeout - (datetime.datetime.utcnow() - last_ok)
 
258
            message = (u'A checker has failed! Time until client'
 
259
                       u' gets diabled: %s'
 
260
                           % unicode(timer).rsplit(".", 1)[0])
 
261
        else:
 
262
            message = u"enabled"
 
263
        self._text = "%s%s" % (base, message)
 
264
            
 
265
        if not urwid.supports_unicode():
 
266
            self._text = self._text.encode("ascii", "replace")
 
267
        textlist = [(u"normal", self._text)]
 
268
        self._text_widget.set_text(textlist)
 
269
        self._focus_text_widget.set_text([(with_standout[text[0]],
 
270
                                           text[1])
 
271
                                          if isinstance(text, tuple)
 
272
                                          else text
 
273
                                          for text in textlist])
 
274
        self._widget = self._text_widget
 
275
        self._focus_widget = urwid.AttrWrap(self._focus_text_widget,
 
276
                                            "standout")
 
277
        # Run update hook, if any
 
278
        if self.update_hook is not None:
 
279
            self.update_hook()
 
280
    
 
281
    def update_timer(self):
 
282
        "called by gobject"
 
283
        self.update()
 
284
        return True             # Keep calling this
 
285
    
 
286
    def delete(self):
 
287
        if self._update_timer_callback_tag is not None:
 
288
            gobject.source_remove(self._update_timer_callback_tag)
 
289
            self._update_timer_callback_tag = None
 
290
        if self.delete_hook is not None:
 
291
            self.delete_hook(self)
 
292
    
 
293
    def render(self, (maxcol,), focus=False):
 
294
        """Render differently if we have focus.
 
295
        This overrides the method from urwid.FlowWidget"""
 
296
        return self.current_widget(focus).render((maxcol,),
 
297
                                                 focus=focus)
 
298
    
 
299
    def keypress(self, (maxcol,), key):
 
300
        """Handle keys.
 
301
        This overrides the method from urwid.FlowWidget"""
 
302
        if key == u"+":
 
303
            self.proxy.Enable(dbus_interface = client_interface)
 
304
        elif key == u"-":
 
305
            self.proxy.Disable(dbus_interface = client_interface)
 
306
        elif key == u"a":
 
307
            self.proxy.Approve(dbus.Boolean(True, variant_level=1),
 
308
                               dbus_interface = client_interface)
 
309
        elif key == u"d":
 
310
            self.proxy.Approve(dbus.Boolean(False, variant_level=1),
 
311
                                  dbus_interface = client_interface)
 
312
        elif key == u"r" or key == u"_" or key == u"ctrl k":
 
313
            self.server_proxy_object.RemoveClient(self.proxy
 
314
                                                  .object_path)
 
315
        elif key == u"s":
 
316
            self.proxy.StartChecker(dbus_interface = client_interface)
 
317
        elif key == u"S":
 
318
            self.proxy.StopChecker(dbus_interface = client_interface)
 
319
        elif key == u"C":
 
320
            self.proxy.CheckedOK(dbus_interface = client_interface)
 
321
        # xxx
 
322
#         elif key == u"p" or key == "=":
 
323
#             self.proxy.pause()
 
324
#         elif key == u"u" or key == ":":
 
325
#             self.proxy.unpause()
 
326
#         elif key == u"RET":
 
327
#             self.open()
 
328
        else:
 
329
            return key
 
330
    
 
331
    def property_changed(self, property=None, value=None,
 
332
                         *args, **kwargs):
 
333
        """Call self.update() if old value is not new value.
 
334
        This overrides the method from MandosClientPropertyCache"""
 
335
        property_name = unicode(property)
 
336
        old_value = self.properties.get(property_name)
 
337
        super(MandosClientWidget, self).property_changed(
 
338
            property=property, value=value, *args, **kwargs)
 
339
        if self.properties.get(property_name) != old_value:
 
340
            self.update()
 
341
 
 
342
 
 
343
class ConstrainedListBox(urwid.ListBox):
 
344
    """Like a normal urwid.ListBox, but will consume all "up" or
 
345
    "down" key presses, thus not allowing any containing widgets to
 
346
    use them as an excuse to shift focus away from this widget.
 
347
    """
 
348
    def keypress(self, (maxcol, maxrow), key):
 
349
        ret = super(ConstrainedListBox, self).keypress((maxcol,
 
350
                                                        maxrow), key)
 
351
        if ret in (u"up", u"down"):
 
352
            return
 
353
        return ret
 
354
 
 
355
 
 
356
class UserInterface(object):
 
357
    """This is the entire user interface - the whole screen
 
358
    with boxes, lists of client widgets, etc.
 
359
    """
 
360
    def __init__(self, max_log_length=1000):
 
361
        DBusGMainLoop(set_as_default=True)
 
362
        
 
363
        self.screen = urwid.curses_display.Screen()
 
364
        
 
365
        self.screen.register_palette((
 
366
                (u"normal",
 
367
                 u"default", u"default", None),
 
368
                (u"bold",
 
369
                 u"default", u"default", u"bold"),
 
370
                (u"underline-blink",
 
371
                 u"default", u"default", u"underline"),
 
372
                (u"standout",
 
373
                 u"default", u"default", u"standout"),
 
374
                (u"bold-underline-blink",
 
375
                 u"default", u"default", (u"bold", u"underline")),
 
376
                (u"bold-standout",
 
377
                 u"default", u"default", (u"bold", u"standout")),
 
378
                (u"underline-blink-standout",
 
379
                 u"default", u"default", (u"underline", u"standout")),
 
380
                (u"bold-underline-blink-standout",
 
381
                 u"default", u"default", (u"bold", u"underline",
 
382
                                          u"standout")),
 
383
                ))
 
384
        
 
385
        if urwid.supports_unicode():
 
386
            self.divider = u"─" # \u2500
 
387
            #self.divider = u"━" # \u2501
 
388
        else:
 
389
            #self.divider = u"-" # \u002d
 
390
            self.divider = u"_" # \u005f
 
391
        
 
392
        self.screen.start()
 
393
        
 
394
        self.size = self.screen.get_cols_rows()
 
395
        
 
396
        self.clients = urwid.SimpleListWalker([])
 
397
        self.clients_dict = {}
 
398
        
 
399
        # We will add Text widgets to this list
 
400
        self.log = []
 
401
        self.max_log_length = max_log_length
 
402
        
 
403
        # We keep a reference to the log widget so we can remove it
 
404
        # from the ListWalker without it getting destroyed
 
405
        self.logbox = ConstrainedListBox(self.log)
 
406
        
 
407
        # This keeps track of whether self.uilist currently has
 
408
        # self.logbox in it or not
 
409
        self.log_visible = True
 
410
        self.log_wrap = u"any"
 
411
        
 
412
        self.rebuild()
 
413
        self.log_message_raw((u"bold",
 
414
                              u"Mandos Monitor version " + version))
 
415
        self.log_message_raw((u"bold",
 
416
                              u"q: Quit  ?: Help"))
 
417
        
 
418
        self.busname = domain + '.Mandos'
 
419
        self.main_loop = gobject.MainLoop()
 
420
        self.bus = dbus.SystemBus()
 
421
        mandos_dbus_objc = self.bus.get_object(
 
422
            self.busname, u"/", follow_name_owner_changes=True)
 
423
        self.mandos_serv = dbus.Interface(mandos_dbus_objc,
 
424
                                          dbus_interface
 
425
                                          = server_interface)
 
426
        try:
 
427
            mandos_clients = (self.mandos_serv
 
428
                              .GetAllClientsWithProperties())
 
429
        except dbus.exceptions.DBusException:
 
430
            mandos_clients = dbus.Dictionary()
 
431
        
 
432
        (self.mandos_serv
 
433
         .connect_to_signal(u"ClientRemoved",
 
434
                            self.find_and_remove_client,
 
435
                            dbus_interface=server_interface,
 
436
                            byte_arrays=True))
 
437
        (self.mandos_serv
 
438
         .connect_to_signal(u"ClientAdded",
 
439
                            self.add_new_client,
 
440
                            dbus_interface=server_interface,
 
441
                            byte_arrays=True))
 
442
        (self.mandos_serv
 
443
         .connect_to_signal(u"ClientNotFound",
 
444
                            self.client_not_found,
 
445
                            dbus_interface=server_interface,
 
446
                            byte_arrays=True))
 
447
        for path, client in mandos_clients.iteritems():
 
448
            client_proxy_object = self.bus.get_object(self.busname,
 
449
                                                      path)
 
450
            self.add_client(MandosClientWidget(server_proxy_object
 
451
                                               =self.mandos_serv,
 
452
                                               proxy_object
 
453
                                               =client_proxy_object,
 
454
                                               properties=client,
 
455
                                               update_hook
 
456
                                               =self.refresh,
 
457
                                               delete_hook
 
458
                                               =self.remove_client,
 
459
                                               logger
 
460
                                               =self.log_message),
 
461
                            path=path)
 
462
    
 
463
    def client_not_found(self, fingerprint, address):
 
464
        self.log_message((u"Client with address %s and fingerprint %s"
 
465
                          u" could not be found" % (address,
 
466
                                                    fingerprint)))
 
467
    
 
468
    def rebuild(self):
 
469
        """This rebuilds the User Interface.
 
470
        Call this when the widget layout needs to change"""
 
471
        self.uilist = []
 
472
        #self.uilist.append(urwid.ListBox(self.clients))
 
473
        self.uilist.append(urwid.Frame(ConstrainedListBox(self.
 
474
                                                          clients),
 
475
                                       #header=urwid.Divider(),
 
476
                                       header=None,
 
477
                                       footer=
 
478
                                       urwid.Divider(div_char=
 
479
                                                     self.divider)))
 
480
        if self.log_visible:
 
481
            self.uilist.append(self.logbox)
 
482
            pass
 
483
        self.topwidget = urwid.Pile(self.uilist)
 
484
    
 
485
    def log_message(self, message):
 
486
        timestamp = datetime.datetime.now().isoformat()
 
487
        self.log_message_raw(timestamp + u": " + message)
 
488
    
 
489
    def log_message_raw(self, markup):
 
490
        """Add a log message to the log buffer."""
 
491
        self.log.append(urwid.Text(markup, wrap=self.log_wrap))
 
492
        if (self.max_log_length
 
493
            and len(self.log) > self.max_log_length):
 
494
            del self.log[0:len(self.log)-self.max_log_length-1]
 
495
        self.logbox.set_focus(len(self.logbox.body.contents),
 
496
                              coming_from=u"above")
 
497
        self.refresh()
 
498
    
 
499
    def toggle_log_display(self):
 
500
        """Toggle visibility of the log buffer."""
 
501
        self.log_visible = not self.log_visible
 
502
        self.rebuild()
 
503
        #self.log_message(u"Log visibility changed to: "
 
504
        #                 + unicode(self.log_visible))
 
505
    
 
506
    def change_log_display(self):
 
507
        """Change type of log display.
 
508
        Currently, this toggles wrapping of text lines."""
 
509
        if self.log_wrap == u"clip":
 
510
            self.log_wrap = u"any"
 
511
        else:
 
512
            self.log_wrap = u"clip"
 
513
        for textwidget in self.log:
 
514
            textwidget.set_wrap_mode(self.log_wrap)
 
515
        #self.log_message(u"Wrap mode: " + self.log_wrap)
 
516
    
 
517
    def find_and_remove_client(self, path, name):
 
518
        """Find an client from its object path and remove it.
 
519
        
 
520
        This is connected to the ClientRemoved signal from the
 
521
        Mandos server object."""
 
522
        try:
 
523
            client = self.clients_dict[path]
 
524
        except KeyError:
 
525
            # not found?
 
526
            return
 
527
        self.remove_client(client, path)
 
528
    
 
529
    def add_new_client(self, path):
 
530
        client_proxy_object = self.bus.get_object(self.busname, path)
 
531
        self.add_client(MandosClientWidget(server_proxy_object
 
532
                                           =self.mandos_serv,
 
533
                                           proxy_object
 
534
                                           =client_proxy_object,
 
535
                                           update_hook
 
536
                                           =self.refresh,
 
537
                                           delete_hook
 
538
                                           =self.remove_client,
 
539
                                           logger
 
540
                                           =self.log_message),
 
541
                        path=path)
 
542
    
 
543
    def add_client(self, client, path=None):
 
544
        self.clients.append(client)
 
545
        if path is None:
 
546
            path = client.proxy.object_path
 
547
        self.clients_dict[path] = client
 
548
        self.clients.sort(None, lambda c: c.properties[u"Name"])
 
549
        self.refresh()
 
550
    
 
551
    def remove_client(self, client, path=None):
 
552
        self.clients.remove(client)
 
553
        if path is None:
 
554
            path = client.proxy.object_path
 
555
        del self.clients_dict[path]
 
556
        if not self.clients_dict:
 
557
            # Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
 
558
            # is completely emptied, we need to recreate it.
 
559
            self.clients = urwid.SimpleListWalker([])
 
560
            self.rebuild()
 
561
        self.refresh()
 
562
    
 
563
    def refresh(self):
 
564
        """Redraw the screen"""
 
565
        canvas = self.topwidget.render(self.size, focus=True)
 
566
        self.screen.draw_screen(self.size, canvas)
 
567
    
 
568
    def run(self):
 
569
        """Start the main loop and exit when it's done."""
 
570
        self.refresh()
 
571
        self._input_callback_tag = (gobject.io_add_watch
 
572
                                    (sys.stdin.fileno(),
 
573
                                     gobject.IO_IN,
 
574
                                     self.process_input))
 
575
        self.main_loop.run()
 
576
        # Main loop has finished, we should close everything now
 
577
        gobject.source_remove(self._input_callback_tag)
 
578
        self.screen.stop()
 
579
    
 
580
    def stop(self):
 
581
        self.main_loop.quit()
 
582
    
 
583
    def process_input(self, source, condition):
 
584
        keys = self.screen.get_input()
 
585
        translations = { u"ctrl n": u"down",      # Emacs
 
586
                         u"ctrl p": u"up",        # Emacs
 
587
                         u"ctrl v": u"page down", # Emacs
 
588
                         u"meta v": u"page up",   # Emacs
 
589
                         u" ": u"page down",      # less
 
590
                         u"f": u"page down",      # less
 
591
                         u"b": u"page up",        # less
 
592
                         u"j": u"down",           # vi
 
593
                         u"k": u"up",             # vi
 
594
                         }
 
595
        for key in keys:
 
596
            try:
 
597
                key = translations[key]
 
598
            except KeyError:    # :-)
 
599
                pass
 
600
            
 
601
            if key == u"q" or key == u"Q":
 
602
                self.stop()
 
603
                break
 
604
            elif key == u"window resize":
 
605
                self.size = self.screen.get_cols_rows()
 
606
                self.refresh()
 
607
            elif key == u"\f":  # Ctrl-L
 
608
                self.refresh()
 
609
            elif key == u"l" or key == u"D":
 
610
                self.toggle_log_display()
 
611
                self.refresh()
 
612
            elif key == u"w" or key == u"i":
 
613
                self.change_log_display()
 
614
                self.refresh()
 
615
            elif key == u"?" or key == u"f1" or key == u"esc":
 
616
                if not self.log_visible:
 
617
                    self.log_visible = True
 
618
                    self.rebuild()
 
619
                self.log_message_raw((u"bold",
 
620
                                      u"  ".
 
621
                                      join((u"q: Quit",
 
622
                                            u"?: Help",
 
623
                                            u"l: Log window toggle",
 
624
                                            u"TAB: Switch window",
 
625
                                            u"w: Wrap (log)"))))
 
626
                self.log_message_raw((u"bold",
 
627
                                      u"  "
 
628
                                      .join((u"Clients:",
 
629
                                             u"+: Enable",
 
630
                                             u"-: Disable",
 
631
                                             u"r: Remove",
 
632
                                             u"s: Start new checker",
 
633
                                             u"S: Stop checker",
 
634
                                             u"C: Checker OK",
 
635
                                             u"a: Approve",
 
636
                                             u"d: Deny"))))
 
637
                self.refresh()
 
638
            elif key == u"tab":
 
639
                if self.topwidget.get_focus() is self.logbox:
 
640
                    self.topwidget.set_focus(0)
 
641
                else:
 
642
                    self.topwidget.set_focus(self.logbox)
 
643
                self.refresh()
 
644
            #elif (key == u"end" or key == u"meta >" or key == u"G"
 
645
            #      or key == u">"):
 
646
            #    pass            # xxx end-of-buffer
 
647
            #elif (key == u"home" or key == u"meta <" or key == u"g"
 
648
            #      or key == u"<"):
 
649
            #    pass            # xxx beginning-of-buffer
 
650
            #elif key == u"ctrl e" or key == u"$":
 
651
            #    pass            # xxx move-end-of-line
 
652
            #elif key == u"ctrl a" or key == u"^":
 
653
            #    pass            # xxx move-beginning-of-line
 
654
            #elif key == u"ctrl b" or key == u"meta (" or key == u"h":
 
655
            #    pass            # xxx left
 
656
            #elif key == u"ctrl f" or key == u"meta )" or key == u"l":
 
657
            #    pass            # xxx right
 
658
            #elif key == u"a":
 
659
            #    pass            # scroll up log
 
660
            #elif key == u"z":
 
661
            #    pass            # scroll down log
 
662
            elif self.topwidget.selectable():
 
663
                self.topwidget.keypress(self.size, key)
 
664
                self.refresh()
 
665
        return True
 
666
 
 
667
ui = UserInterface()
 
668
try:
 
669
    ui.run()
 
670
except KeyboardInterrupt:
 
671
    ui.screen.stop()
 
672
except Exception, e:
 
673
    ui.log_message(unicode(e))
 
674
    ui.screen.stop()
 
675
    raise