/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 Hogeborn
  • Date: 2010-09-12 03:00:40 UTC
  • Revision ID: teddy@fukt.bsnet.se-20100912030040-b0uopyennste9fdh
Documentation changes:

* DBUS-API: New file documenting the server D-Bus interface.

* clients.conf: Add examples of new approval settings.

* debian/mandos.docs: Added "DBUS-API".

* mandos-clients.conf.xml (OPTIONS): Added "approved_by_default",
                                     "approval_delay", and
                                     "approval_duration".
* mandos.xml (D-BUS INTERFACE): Refer to the "DBUS-API" file.
  (BUGS): Remove mention of lack of a remote query interface.

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
#        elif key == u"+":
 
329
#            self.proxy.Approve(True)
 
330
#        elif key == u"-":
 
331
#            self.proxy.Approve(False)
 
332
        else:
 
333
            return key
 
334
    
 
335
    def property_changed(self, property=None, value=None,
 
336
                         *args, **kwargs):
 
337
        """Call self.update() if old value is not new value.
 
338
        This overrides the method from MandosClientPropertyCache"""
 
339
        property_name = unicode(property)
 
340
        old_value = self.properties.get(property_name)
 
341
        super(MandosClientWidget, self).property_changed(
 
342
            property=property, value=value, *args, **kwargs)
 
343
        if self.properties.get(property_name) != old_value:
 
344
            self.update()
 
345
 
 
346
 
 
347
class ConstrainedListBox(urwid.ListBox):
 
348
    """Like a normal urwid.ListBox, but will consume all "up" or
 
349
    "down" key presses, thus not allowing any containing widgets to
 
350
    use them as an excuse to shift focus away from this widget.
 
351
    """
 
352
    def keypress(self, (maxcol, maxrow), key):
 
353
        ret = super(ConstrainedListBox, self).keypress((maxcol,
 
354
                                                        maxrow), key)
 
355
        if ret in (u"up", u"down"):
 
356
            return
 
357
        return ret
 
358
 
 
359
 
 
360
class UserInterface(object):
 
361
    """This is the entire user interface - the whole screen
 
362
    with boxes, lists of client widgets, etc.
 
363
    """
 
364
    def __init__(self, max_log_length=1000):
 
365
        DBusGMainLoop(set_as_default=True)
 
366
        
 
367
        self.screen = urwid.curses_display.Screen()
 
368
        
 
369
        self.screen.register_palette((
 
370
                (u"normal",
 
371
                 u"default", u"default", None),
 
372
                (u"bold",
 
373
                 u"default", u"default", u"bold"),
 
374
                (u"underline-blink",
 
375
                 u"default", u"default", u"underline"),
 
376
                (u"standout",
 
377
                 u"default", u"default", u"standout"),
 
378
                (u"bold-underline-blink",
 
379
                 u"default", u"default", (u"bold", u"underline")),
 
380
                (u"bold-standout",
 
381
                 u"default", u"default", (u"bold", u"standout")),
 
382
                (u"underline-blink-standout",
 
383
                 u"default", u"default", (u"underline", u"standout")),
 
384
                (u"bold-underline-blink-standout",
 
385
                 u"default", u"default", (u"bold", u"underline",
 
386
                                          u"standout")),
 
387
                ))
 
388
        
 
389
        if urwid.supports_unicode():
 
390
            self.divider = u"─" # \u2500
 
391
            #self.divider = u"━" # \u2501
 
392
        else:
 
393
            #self.divider = u"-" # \u002d
 
394
            self.divider = u"_" # \u005f
 
395
        
 
396
        self.screen.start()
 
397
        
 
398
        self.size = self.screen.get_cols_rows()
 
399
        
 
400
        self.clients = urwid.SimpleListWalker([])
 
401
        self.clients_dict = {}
 
402
        
 
403
        # We will add Text widgets to this list
 
404
        self.log = []
 
405
        self.max_log_length = max_log_length
 
406
        
 
407
        # We keep a reference to the log widget so we can remove it
 
408
        # from the ListWalker without it getting destroyed
 
409
        self.logbox = ConstrainedListBox(self.log)
 
410
        
 
411
        # This keeps track of whether self.uilist currently has
 
412
        # self.logbox in it or not
 
413
        self.log_visible = True
 
414
        self.log_wrap = u"any"
 
415
        
 
416
        self.rebuild()
 
417
        self.log_message_raw((u"bold",
 
418
                              u"Mandos Monitor version " + version))
 
419
        self.log_message_raw((u"bold",
 
420
                              u"q: Quit  ?: Help"))
 
421
        
 
422
        self.busname = domain + '.Mandos'
 
423
        self.main_loop = gobject.MainLoop()
 
424
        self.bus = dbus.SystemBus()
 
425
        mandos_dbus_objc = self.bus.get_object(
 
426
            self.busname, u"/", follow_name_owner_changes=True)
 
427
        self.mandos_serv = dbus.Interface(mandos_dbus_objc,
 
428
                                          dbus_interface
 
429
                                          = server_interface)
 
430
        try:
 
431
            mandos_clients = (self.mandos_serv
 
432
                              .GetAllClientsWithProperties())
 
433
        except dbus.exceptions.DBusException:
 
434
            mandos_clients = dbus.Dictionary()
 
435
        
 
436
        (self.mandos_serv
 
437
         .connect_to_signal(u"ClientRemoved",
 
438
                            self.find_and_remove_client,
 
439
                            dbus_interface=server_interface,
 
440
                            byte_arrays=True))
 
441
        (self.mandos_serv
 
442
         .connect_to_signal(u"ClientAdded",
 
443
                            self.add_new_client,
 
444
                            dbus_interface=server_interface,
 
445
                            byte_arrays=True))
 
446
        (self.mandos_serv
 
447
         .connect_to_signal(u"ClientNotFound",
 
448
                            self.client_not_found,
 
449
                            dbus_interface=server_interface,
 
450
                            byte_arrays=True))
 
451
        for path, client in mandos_clients.iteritems():
 
452
            client_proxy_object = self.bus.get_object(self.busname,
 
453
                                                      path)
 
454
            self.add_client(MandosClientWidget(server_proxy_object
 
455
                                               =self.mandos_serv,
 
456
                                               proxy_object
 
457
                                               =client_proxy_object,
 
458
                                               properties=client,
 
459
                                               update_hook
 
460
                                               =self.refresh,
 
461
                                               delete_hook
 
462
                                               =self.remove_client,
 
463
                                               logger
 
464
                                               =self.log_message),
 
465
                            path=path)
 
466
    
 
467
    def client_not_found(self, fingerprint, address):
 
468
        self.log_message((u"Client with address %s and fingerprint %s"
 
469
                          u" could not be found" % (address,
 
470
                                                    fingerprint)))
 
471
    
 
472
    def rebuild(self):
 
473
        """This rebuilds the User Interface.
 
474
        Call this when the widget layout needs to change"""
 
475
        self.uilist = []
 
476
        #self.uilist.append(urwid.ListBox(self.clients))
 
477
        self.uilist.append(urwid.Frame(ConstrainedListBox(self.
 
478
                                                          clients),
 
479
                                       #header=urwid.Divider(),
 
480
                                       header=None,
 
481
                                       footer=
 
482
                                       urwid.Divider(div_char=
 
483
                                                     self.divider)))
 
484
        if self.log_visible:
 
485
            self.uilist.append(self.logbox)
 
486
            pass
 
487
        self.topwidget = urwid.Pile(self.uilist)
 
488
    
 
489
    def log_message(self, message):
 
490
        timestamp = datetime.datetime.now().isoformat()
 
491
        self.log_message_raw(timestamp + u": " + message)
 
492
    
 
493
    def log_message_raw(self, markup):
 
494
        """Add a log message to the log buffer."""
 
495
        self.log.append(urwid.Text(markup, wrap=self.log_wrap))
 
496
        if (self.max_log_length
 
497
            and len(self.log) > self.max_log_length):
 
498
            del self.log[0:len(self.log)-self.max_log_length-1]
 
499
        self.logbox.set_focus(len(self.logbox.body.contents),
 
500
                              coming_from=u"above")
 
501
        self.refresh()
 
502
    
 
503
    def toggle_log_display(self):
 
504
        """Toggle visibility of the log buffer."""
 
505
        self.log_visible = not self.log_visible
 
506
        self.rebuild()
 
507
        self.log_message(u"Log visibility changed to: "
 
508
                         + unicode(self.log_visible))
 
509
    
 
510
    def change_log_display(self):
 
511
        """Change type of log display.
 
512
        Currently, this toggles wrapping of text lines."""
 
513
        if self.log_wrap == u"clip":
 
514
            self.log_wrap = u"any"
 
515
        else:
 
516
            self.log_wrap = u"clip"
 
517
        for textwidget in self.log:
 
518
            textwidget.set_wrap_mode(self.log_wrap)
 
519
        self.log_message(u"Wrap mode: " + self.log_wrap)
 
520
    
 
521
    def find_and_remove_client(self, path, name):
 
522
        """Find an client from its object path and remove it.
 
523
        
 
524
        This is connected to the ClientRemoved signal from the
 
525
        Mandos server object."""
 
526
        try:
 
527
            client = self.clients_dict[path]
 
528
        except KeyError:
 
529
            # not found?
 
530
            return
 
531
        self.remove_client(client, path)
 
532
    
 
533
    def add_new_client(self, path):
 
534
        client_proxy_object = self.bus.get_object(self.busname, path)
 
535
        self.add_client(MandosClientWidget(server_proxy_object
 
536
                                           =self.mandos_serv,
 
537
                                           proxy_object
 
538
                                           =client_proxy_object,
 
539
                                           update_hook
 
540
                                           =self.refresh,
 
541
                                           delete_hook
 
542
                                           =self.remove_client,
 
543
                                           logger
 
544
                                           =self.log_message),
 
545
                        path=path)
 
546
    
 
547
    def add_client(self, client, path=None):
 
548
        self.clients.append(client)
 
549
        if path is None:
 
550
            path = client.proxy.object_path
 
551
        self.clients_dict[path] = client
 
552
        self.clients.sort(None, lambda c: c.properties[u"Name"])
 
553
        self.refresh()
 
554
    
 
555
    def remove_client(self, client, path=None):
 
556
        self.clients.remove(client)
 
557
        if path is None:
 
558
            path = client.proxy.object_path
 
559
        del self.clients_dict[path]
 
560
        if not self.clients_dict:
 
561
            # Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
 
562
            # is completely emptied, we need to recreate it.
 
563
            self.clients = urwid.SimpleListWalker([])
 
564
            self.rebuild()
 
565
        self.refresh()
 
566
    
 
567
    def refresh(self):
 
568
        """Redraw the screen"""
 
569
        canvas = self.topwidget.render(self.size, focus=True)
 
570
        self.screen.draw_screen(self.size, canvas)
 
571
    
 
572
    def run(self):
 
573
        """Start the main loop and exit when it's done."""
 
574
        self.refresh()
 
575
        self._input_callback_tag = (gobject.io_add_watch
 
576
                                    (sys.stdin.fileno(),
 
577
                                     gobject.IO_IN,
 
578
                                     self.process_input))
 
579
        self.main_loop.run()
 
580
        # Main loop has finished, we should close everything now
 
581
        gobject.source_remove(self._input_callback_tag)
 
582
        self.screen.stop()
 
583
    
 
584
    def stop(self):
 
585
        self.main_loop.quit()
 
586
    
 
587
    def process_input(self, source, condition):
 
588
        keys = self.screen.get_input()
 
589
        translations = { u"ctrl n": u"down",      # Emacs
 
590
                         u"ctrl p": u"up",        # Emacs
 
591
                         u"ctrl v": u"page down", # Emacs
 
592
                         u"meta v": u"page up",   # Emacs
 
593
                         u" ": u"page down",      # less
 
594
                         u"f": u"page down",      # less
 
595
                         u"b": u"page up",        # less
 
596
                         u"j": u"down",           # vi
 
597
                         u"k": u"up",             # vi
 
598
                         }
 
599
        for key in keys:
 
600
            try:
 
601
                key = translations[key]
 
602
            except KeyError:    # :-)
 
603
                pass
 
604
            
 
605
            if key == u"q" or key == u"Q":
 
606
                self.stop()
 
607
                break
 
608
            elif key == u"window resize":
 
609
                self.size = self.screen.get_cols_rows()
 
610
                self.refresh()
 
611
            elif key == u"\f":  # Ctrl-L
 
612
                self.refresh()
 
613
            elif key == u"l" or key == u"D":
 
614
                self.toggle_log_display()
 
615
                self.refresh()
 
616
            elif key == u"w" or key == u"i":
 
617
                self.change_log_display()
 
618
                self.refresh()
 
619
            elif key == u"?" or key == u"f1" or key == u"esc":
 
620
                if not self.log_visible:
 
621
                    self.log_visible = True
 
622
                    self.rebuild()
 
623
                self.log_message_raw((u"bold",
 
624
                                      u"  ".
 
625
                                      join((u"q: Quit",
 
626
                                            u"?: Help",
 
627
                                            u"l: Log window toggle",
 
628
                                            u"TAB: Switch window",
 
629
                                            u"w: Wrap (log)"))))
 
630
                self.log_message_raw((u"bold",
 
631
                                      u"  "
 
632
                                      .join((u"Clients:",
 
633
                                             u"+: Enable",
 
634
                                             u"-: Disable",
 
635
                                             u"r: Remove",
 
636
                                             u"s: Start new checker",
 
637
                                             u"S: Stop checker",
 
638
                                             u"C: Checker OK",
 
639
                                             u"a: Approve",
 
640
                                             u"d: Deny"))))
 
641
                self.refresh()
 
642
            elif key == u"tab":
 
643
                if self.topwidget.get_focus() is self.logbox:
 
644
                    self.topwidget.set_focus(0)
 
645
                else:
 
646
                    self.topwidget.set_focus(self.logbox)
 
647
                self.refresh()
 
648
            #elif (key == u"end" or key == u"meta >" or key == u"G"
 
649
            #      or key == u">"):
 
650
            #    pass            # xxx end-of-buffer
 
651
            #elif (key == u"home" or key == u"meta <" or key == u"g"
 
652
            #      or key == u"<"):
 
653
            #    pass            # xxx beginning-of-buffer
 
654
            #elif key == u"ctrl e" or key == u"$":
 
655
            #    pass            # xxx move-end-of-line
 
656
            #elif key == u"ctrl a" or key == u"^":
 
657
            #    pass            # xxx move-beginning-of-line
 
658
            #elif key == u"ctrl b" or key == u"meta (" or key == u"h":
 
659
            #    pass            # xxx left
 
660
            #elif key == u"ctrl f" or key == u"meta )" or key == u"l":
 
661
            #    pass            # xxx right
 
662
            #elif key == u"a":
 
663
            #    pass            # scroll up log
 
664
            #elif key == u"z":
 
665
            #    pass            # scroll down log
 
666
            elif self.topwidget.selectable():
 
667
                self.topwidget.keypress(self.size, key)
 
668
                self.refresh()
 
669
        return True
 
670
 
 
671
ui = UserInterface()
 
672
try:
 
673
    ui.run()
 
674
except KeyboardInterrupt:
 
675
    ui.screen.stop()
 
676
except Exception, e:
 
677
    ui.log_message(unicode(e))
 
678
    ui.screen.stop()
 
679
    raise