/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: 2009-02-09 02:01:13 UTC
  • Revision ID: teddy@fukt.bsnet.se-20090209020113-726hq380zvp8zt97
Four new interrelated features:

1. Support using a different network interface via both initramfs.conf
   (the DEVICE setting) and the kernel command line (sixth field of
   the "ip=" option as in Linux' Documentation/nfsroot.txt).

2. Support connecting to a specified Mandos server directly using a
   kernel command line option ("mandos=connect:<ADDRESS>:<PORT>").

3. Support connecting directly to an IPv4 address (and port) using the
   "--connect" option of mandos-client.

4. Support an empty string to the --interface option to mandos-client.

* Makefile (WARN): Increase strictness by changing to
                   "-Wstrict-aliasing=1".

* debian/mandos-client.README.Debian (Use the Correct Network
  Interface): Changed to refer to initramfs.conf and nfsroot.txt.
  (Test the Server): Improve wording.
  (Non-local Connection): New section.
* initramfs-tools-script: Obey DEVICE environment variable and setting
                          from "/conf/initramfs.conf".  Also let any
                          "ip=" kernel command line option override
                          it.  Support new "mandos=connect" option.
                          Call "configure_networking" to set up IP
                          address on interface if necessary.
* plugin-runner.conf: Change example.
* plugins.d/mandos-client.c: Some whitespace and comment changes.
  (start_mandos_communication): Take an additional argument for
                                address family, all callers changed.
                                Connect to an IPv4 address if address
                                family is AF_INET.  Only set IPv6
                                scope_id for link-local addresses.
  (main): Accept empty interface name; this will not bring up any
         interface and leave the interface as unspecified.  Also do
         not restore kernel log level if lowering it failed.
* plugins.d/mandos-client.xml (OPTIONS): Document that the
                                         "--interface" option accepts
                                         an empty string.
  (EXAMPLE): Change example IPv6 address to a link-local address.

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
 
                                                ["last_checked_ok"])
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["interval"]))
146
 
        if self.last_checker_failed:
147
 
            self._update_timer_callback_tag = (gobject.timeout_add
148
 
                                               (1000,
149
 
                                                self.update_timer))
150
 
    
151
 
    def checker_completed(self, exitstatus, condition, command):
152
 
        if exitstatus == 0:
153
 
            if self.last_checker_failed:
154
 
                self.last_checker_failed = False
155
 
                gobject.source_remove(self._update_timer_callback_tag)
156
 
                self._update_timer_callback_tag = None
157
 
            self.logger(u'Checker for client %s (command "%s")'
158
 
                        u' was successful'
159
 
                        % (self.properties[u"name"], command))
160
 
            self.update()
161
 
            return
162
 
        # Checker failed
163
 
        if not self.last_checker_failed:
164
 
            self.last_checker_failed = True
165
 
            self._update_timer_callback_tag = (gobject.timeout_add
166
 
                                               (1000,
167
 
                                                self.update_timer))
168
 
        if os.WIFEXITED(condition):
169
 
            self.logger(u'Checker for client %s (command "%s")'
170
 
                        u' failed with exit code %s'
171
 
                        % (self.properties[u"name"], command,
172
 
                           os.WEXITSTATUS(condition)))
173
 
        elif os.WIFSIGNALED(condition):
174
 
            self.logger(u'Checker for client %s (command "%s")'
175
 
                        u' was killed by signal %s'
176
 
                        % (self.properties[u"name"], command,
177
 
                           os.WTERMSIG(condition)))
178
 
        elif os.WCOREDUMP(condition):
179
 
            self.logger(u'Checker for client %s (command "%s")'
180
 
                        u' dumped core'
181
 
                        % (self.properties[u"name"], command))
182
 
        else:
183
 
            self.logger(u'Checker for client %s completed mysteriously')
184
 
        self.update()
185
 
    
186
 
    def checker_started(self, command):
187
 
        #self.logger(u'Client %s started checker "%s"'
188
 
        #            % (self.properties[u"name"], unicode(command)))
189
 
        pass
190
 
    
191
 
    def got_secret(self):
192
 
        self.last_checker_failed = False
193
 
        self.logger(u'Client %s received its secret'
194
 
                    % self.properties[u"name"])
195
 
    
196
 
    def need_approval(self, timeout, default):
197
 
        if not default:
198
 
            message = u'Client %s needs approval within %s seconds'
199
 
        else:
200
 
            message = u'Client %s will get its secret in %s seconds'
201
 
        self.logger(message
202
 
                    % (self.properties[u"name"], timeout/1000))
203
 
    
204
 
    def rejected(self, reason):
205
 
        self.logger(u'Client %s was rejected; reason: %s'
206
 
                    % (self.properties[u"name"], reason))
207
 
    
208
 
    def selectable(self):
209
 
        """Make this a "selectable" widget.
210
 
        This overrides the method from urwid.FlowWidget."""
211
 
        return True
212
 
    
213
 
    def rows(self, (maxcol,), focus=False):
214
 
        """How many rows this widget will occupy might depend on
215
 
        whether we have focus or not.
216
 
        This overrides the method from urwid.FlowWidget"""
217
 
        return self.current_widget(focus).rows((maxcol,), focus=focus)
218
 
    
219
 
    def current_widget(self, focus=False):
220
 
        if focus or self.opened:
221
 
            return self._focus_widget
222
 
        return self._widget
223
 
    
224
 
    def update(self):
225
 
        "Called when what is visible on the screen should be updated."
226
 
        # How to add standout mode to a style
227
 
        with_standout = { u"normal": u"standout",
228
 
                          u"bold": u"bold-standout",
229
 
                          u"underline-blink":
230
 
                              u"underline-blink-standout",
231
 
                          u"bold-underline-blink":
232
 
                              u"bold-underline-blink-standout",
233
 
                          }
234
 
 
235
 
        # Rebuild focus and non-focus widgets using current properties
236
 
 
237
 
        # Base part of a client. Name!
238
 
        base = (u'%(name)s: '
239
 
                      % {u"name": self.properties[u"name"]})
240
 
        if not self.properties[u"enabled"]:
241
 
            message = u"DISABLED"
242
 
        elif self.properties[u"approved_pending"]:
243
 
            if self.properties[u"approved_by_default"]:
244
 
                message = u"Connection established to client. (d)eny?"
245
 
            else:
246
 
                message = u"Seeks approval to send secret. (a)pprove?"
247
 
        elif self.last_checker_failed:
248
 
            timeout = datetime.timedelta(milliseconds
249
 
                                         = self.properties[u"timeout"])
250
 
            last_ok = isoformat_to_datetime(
251
 
                max((self.properties["last_checked_ok"]
252
 
                     or self.properties["created"]),
253
 
                    self.properties[u"last_enabled"]))
254
 
            timer = timeout - (datetime.datetime.utcnow() - last_ok)
255
 
            message = (u'A checker has failed! Time until client gets diabled: %s'
256
 
                           % unicode(timer).rsplit(".", 1)[0])
257
 
        else:
258
 
            message = u"enabled"
259
 
        self._text = "%s%s" % (base, message)
260
 
            
261
 
        if not urwid.supports_unicode():
262
 
            self._text = self._text.encode("ascii", "replace")
263
 
        textlist = [(u"normal", self._text)]
264
 
        self._text_widget.set_text(textlist)
265
 
        self._focus_text_widget.set_text([(with_standout[text[0]],
266
 
                                           text[1])
267
 
                                          if isinstance(text, tuple)
268
 
                                          else text
269
 
                                          for text in textlist])
270
 
        self._widget = self._text_widget
271
 
        self._focus_widget = urwid.AttrWrap(self._focus_text_widget,
272
 
                                            "standout")
273
 
        # Run update hook, if any
274
 
        if self.update_hook is not None:
275
 
            self.update_hook()
276
 
    
277
 
    def update_timer(self):
278
 
        "called by gobject"
279
 
        self.update()
280
 
        return True             # Keep calling this
281
 
    
282
 
    def delete(self):
283
 
        if self._update_timer_callback_tag is not None:
284
 
            gobject.source_remove(self._update_timer_callback_tag)
285
 
            self._update_timer_callback_tag = None
286
 
        if self.delete_hook is not None:
287
 
            self.delete_hook(self)
288
 
    
289
 
    def render(self, (maxcol,), focus=False):
290
 
        """Render differently if we have focus.
291
 
        This overrides the method from urwid.FlowWidget"""
292
 
        return self.current_widget(focus).render((maxcol,),
293
 
                                                 focus=focus)
294
 
    
295
 
    def keypress(self, (maxcol,), key):
296
 
        """Handle keys.
297
 
        This overrides the method from urwid.FlowWidget"""
298
 
        if key == u"+":
299
 
            self.proxy.Enable(dbus_interface = client_interface)
300
 
        elif key == u"-":
301
 
            self.proxy.Disable(dbus_interface = client_interface)
302
 
        elif key == u"a":
303
 
            self.proxy.Approve(dbus.Boolean(True, variant_level=1),
304
 
                               dbus_interface = client_interface)
305
 
        elif key == u"d":
306
 
            self.proxy.Approve(dbus.Boolean(False, variant_level=1),
307
 
                                  dbus_interface = client_interface)
308
 
        elif key == u"r" or key == u"_" or key == u"ctrl k":
309
 
            self.server_proxy_object.RemoveClient(self.proxy
310
 
                                                  .object_path)
311
 
        elif key == u"s":
312
 
            self.proxy.StartChecker(dbus_interface = client_interface)
313
 
        elif key == u"S":
314
 
            self.proxy.StopChecker(dbus_interface = client_interface)
315
 
        elif key == u"C":
316
 
            self.proxy.CheckedOK(dbus_interface = client_interface)
317
 
        # xxx
318
 
#         elif key == u"p" or key == "=":
319
 
#             self.proxy.pause()
320
 
#         elif key == u"u" or key == ":":
321
 
#             self.proxy.unpause()
322
 
#         elif key == u"RET":
323
 
#             self.open()
324
 
#        elif key == u"+":
325
 
#            self.proxy.Approve(True)
326
 
#        elif key == u"-":
327
 
#            self.proxy.Approve(False)
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, maxrow), key)
350
 
        if ret in (u"up", u"down"):
351
 
            return
352
 
        return ret
353
 
 
354
 
 
355
 
class UserInterface(object):
356
 
    """This is the entire user interface - the whole screen
357
 
    with boxes, lists of client widgets, etc.
358
 
    """
359
 
    def __init__(self, max_log_length=1000):
360
 
        DBusGMainLoop(set_as_default=True)
361
 
        
362
 
        self.screen = urwid.curses_display.Screen()
363
 
        
364
 
        self.screen.register_palette((
365
 
                (u"normal",
366
 
                 u"default", u"default", None),
367
 
                (u"bold",
368
 
                 u"default", u"default", u"bold"),
369
 
                (u"underline-blink",
370
 
                 u"default", u"default", u"underline"),
371
 
                (u"standout",
372
 
                 u"default", u"default", u"standout"),
373
 
                (u"bold-underline-blink",
374
 
                 u"default", u"default", (u"bold", u"underline")),
375
 
                (u"bold-standout",
376
 
                 u"default", u"default", (u"bold", u"standout")),
377
 
                (u"underline-blink-standout",
378
 
                 u"default", u"default", (u"underline", u"standout")),
379
 
                (u"bold-underline-blink-standout",
380
 
                 u"default", u"default", (u"bold", u"underline",
381
 
                                          u"standout")),
382
 
                ))
383
 
        
384
 
        if urwid.supports_unicode():
385
 
            self.divider = u"─" # \u2500
386
 
            #self.divider = u"━" # \u2501
387
 
        else:
388
 
            #self.divider = u"-" # \u002d
389
 
            self.divider = u"_" # \u005f
390
 
        
391
 
        self.screen.start()
392
 
        
393
 
        self.size = self.screen.get_cols_rows()
394
 
        
395
 
        self.clients = urwid.SimpleListWalker([])
396
 
        self.clients_dict = {}
397
 
        
398
 
        # We will add Text widgets to this list
399
 
        self.log = []
400
 
        self.max_log_length = max_log_length
401
 
        
402
 
        # We keep a reference to the log widget so we can remove it
403
 
        # from the ListWalker without it getting destroyed
404
 
        self.logbox = ConstrainedListBox(self.log)
405
 
        
406
 
        # This keeps track of whether self.uilist currently has
407
 
        # self.logbox in it or not
408
 
        self.log_visible = True
409
 
        self.log_wrap = u"any"
410
 
        
411
 
        self.rebuild()
412
 
        self.log_message_raw((u"bold",
413
 
                              u"Mandos Monitor version " + version))
414
 
        self.log_message_raw((u"bold",
415
 
                              u"q: Quit  ?: Help"))
416
 
        
417
 
        self.busname = domain + '.Mandos'
418
 
        self.main_loop = gobject.MainLoop()
419
 
        self.bus = dbus.SystemBus()
420
 
        mandos_dbus_objc = self.bus.get_object(
421
 
            self.busname, u"/", follow_name_owner_changes=True)
422
 
        self.mandos_serv = dbus.Interface(mandos_dbus_objc,
423
 
                                          dbus_interface
424
 
                                          = server_interface)
425
 
        try:
426
 
            mandos_clients = (self.mandos_serv
427
 
                              .GetAllClientsWithProperties())
428
 
        except dbus.exceptions.DBusException:
429
 
            mandos_clients = dbus.Dictionary()
430
 
        
431
 
        (self.mandos_serv
432
 
         .connect_to_signal(u"ClientRemoved",
433
 
                            self.find_and_remove_client,
434
 
                            dbus_interface=server_interface,
435
 
                            byte_arrays=True))
436
 
        (self.mandos_serv
437
 
         .connect_to_signal(u"ClientAdded",
438
 
                            self.add_new_client,
439
 
                            dbus_interface=server_interface,
440
 
                            byte_arrays=True))
441
 
        (self.mandos_serv
442
 
         .connect_to_signal(u"ClientNotFound",
443
 
                            self.client_not_found,
444
 
                            dbus_interface=server_interface,
445
 
                            byte_arrays=True))
446
 
        for path, client in mandos_clients.iteritems():
447
 
            client_proxy_object = self.bus.get_object(self.busname,
448
 
                                                      path)
449
 
            self.add_client(MandosClientWidget(server_proxy_object
450
 
                                               =self.mandos_serv,
451
 
                                               proxy_object
452
 
                                               =client_proxy_object,
453
 
                                               properties=client,
454
 
                                               update_hook
455
 
                                               =self.refresh,
456
 
                                               delete_hook
457
 
                                               =self.remove_client,
458
 
                                               logger
459
 
                                               =self.log_message),
460
 
                            path=path)
461
 
    
462
 
    def client_not_found(self, fingerprint, address):
463
 
        self.log_message((u"Client with address %s and fingerprint %s"
464
 
                          u" could not be found" % (address,
465
 
                                                    fingerprint)))
466
 
    
467
 
    def rebuild(self):
468
 
        """This rebuilds the User Interface.
469
 
        Call this when the widget layout needs to change"""
470
 
        self.uilist = []
471
 
        #self.uilist.append(urwid.ListBox(self.clients))
472
 
        self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),
473
 
                                       #header=urwid.Divider(),
474
 
                                       header=None,
475
 
                                       footer=urwid.Divider(div_char=self.divider)))
476
 
        if self.log_visible:
477
 
            self.uilist.append(self.logbox)
478
 
            pass
479
 
        self.topwidget = urwid.Pile(self.uilist)
480
 
    
481
 
    def log_message(self, message):
482
 
        timestamp = datetime.datetime.now().isoformat()
483
 
        self.log_message_raw(timestamp + u": " + message)
484
 
    
485
 
    def log_message_raw(self, markup):
486
 
        """Add a log message to the log buffer."""
487
 
        self.log.append(urwid.Text(markup, wrap=self.log_wrap))
488
 
        if (self.max_log_length
489
 
            and len(self.log) > self.max_log_length):
490
 
            del self.log[0:len(self.log)-self.max_log_length-1]
491
 
        self.logbox.set_focus(len(self.logbox.body.contents),
492
 
                              coming_from=u"above")
493
 
        self.refresh()
494
 
    
495
 
    def toggle_log_display(self):
496
 
        """Toggle visibility of the log buffer."""
497
 
        self.log_visible = not self.log_visible
498
 
        self.rebuild()
499
 
        self.log_message(u"Log visibility changed to: "
500
 
                         + unicode(self.log_visible))
501
 
    
502
 
    def change_log_display(self):
503
 
        """Change type of log display.
504
 
        Currently, this toggles wrapping of text lines."""
505
 
        if self.log_wrap == u"clip":
506
 
            self.log_wrap = u"any"
507
 
        else:
508
 
            self.log_wrap = u"clip"
509
 
        for textwidget in self.log:
510
 
            textwidget.set_wrap_mode(self.log_wrap)
511
 
        self.log_message(u"Wrap mode: " + self.log_wrap)
512
 
    
513
 
    def find_and_remove_client(self, path, name):
514
 
        """Find an client from its object path and remove it.
515
 
        
516
 
        This is connected to the ClientRemoved signal from the
517
 
        Mandos server object."""
518
 
        try:
519
 
            client = self.clients_dict[path]
520
 
        except KeyError:
521
 
            # not found?
522
 
            return
523
 
        self.remove_client(client, path)
524
 
    
525
 
    def add_new_client(self, path):
526
 
        client_proxy_object = self.bus.get_object(self.busname, path)
527
 
        self.add_client(MandosClientWidget(server_proxy_object
528
 
                                           =self.mandos_serv,
529
 
                                           proxy_object
530
 
                                           =client_proxy_object,
531
 
                                           update_hook
532
 
                                           =self.refresh,
533
 
                                           delete_hook
534
 
                                           =self.remove_client,
535
 
                                           logger
536
 
                                           =self.log_message),
537
 
                        path=path)
538
 
    
539
 
    def add_client(self, client, path=None):
540
 
        self.clients.append(client)
541
 
        if path is None:
542
 
            path = client.proxy.object_path
543
 
        self.clients_dict[path] = client
544
 
        self.clients.sort(None, lambda c: c.properties[u"name"])
545
 
        self.refresh()
546
 
    
547
 
    def remove_client(self, client, path=None):
548
 
        self.clients.remove(client)
549
 
        if path is None:
550
 
            path = client.proxy.object_path
551
 
        del self.clients_dict[path]
552
 
        if not self.clients_dict:
553
 
            # Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
554
 
            # is completely emptied, we need to recreate it.
555
 
            self.clients = urwid.SimpleListWalker([])
556
 
            self.rebuild()
557
 
        self.refresh()
558
 
    
559
 
    def refresh(self):
560
 
        """Redraw the screen"""
561
 
        canvas = self.topwidget.render(self.size, focus=True)
562
 
        self.screen.draw_screen(self.size, canvas)
563
 
    
564
 
    def run(self):
565
 
        """Start the main loop and exit when it's done."""
566
 
        self.refresh()
567
 
        self._input_callback_tag = (gobject.io_add_watch
568
 
                                    (sys.stdin.fileno(),
569
 
                                     gobject.IO_IN,
570
 
                                     self.process_input))
571
 
        self.main_loop.run()
572
 
        # Main loop has finished, we should close everything now
573
 
        gobject.source_remove(self._input_callback_tag)
574
 
        self.screen.stop()
575
 
    
576
 
    def stop(self):
577
 
        self.main_loop.quit()
578
 
    
579
 
    def process_input(self, source, condition):
580
 
        keys = self.screen.get_input()
581
 
        translations = { u"ctrl n": u"down",      # Emacs
582
 
                         u"ctrl p": u"up",        # Emacs
583
 
                         u"ctrl v": u"page down", # Emacs
584
 
                         u"meta v": u"page up",   # Emacs
585
 
                         u" ": u"page down",      # less
586
 
                         u"f": u"page down",      # less
587
 
                         u"b": u"page up",        # less
588
 
                         u"j": u"down",           # vi
589
 
                         u"k": u"up",             # vi
590
 
                         }
591
 
        for key in keys:
592
 
            try:
593
 
                key = translations[key]
594
 
            except KeyError:    # :-)
595
 
                pass
596
 
            
597
 
            if key == u"q" or key == u"Q":
598
 
                self.stop()
599
 
                break
600
 
            elif key == u"window resize":
601
 
                self.size = self.screen.get_cols_rows()
602
 
                self.refresh()
603
 
            elif key == u"\f":  # Ctrl-L
604
 
                self.refresh()
605
 
            elif key == u"l" or key == u"D":
606
 
                self.toggle_log_display()
607
 
                self.refresh()
608
 
            elif key == u"w" or key == u"i":
609
 
                self.change_log_display()
610
 
                self.refresh()
611
 
            elif key == u"?" or key == u"f1" or key == u"esc":
612
 
                if not self.log_visible:
613
 
                    self.log_visible = True
614
 
                    self.rebuild()
615
 
                self.log_message_raw((u"bold",
616
 
                                      u"  ".
617
 
                                      join((u"q: Quit",
618
 
                                            u"?: Help",
619
 
                                            u"l: Log window toggle",
620
 
                                            u"TAB: Switch window",
621
 
                                            u"w: Wrap (log)"))))
622
 
                self.log_message_raw((u"bold",
623
 
                                      u"  "
624
 
                                      .join((u"Clients:",
625
 
                                             u"+: Enable",
626
 
                                             u"-: Disable",
627
 
                                             u"r: Remove",
628
 
                                             u"s: Start new checker",
629
 
                                             u"S: Stop checker",
630
 
                                             u"C: Checker OK",
631
 
                                             u"a: Approve",
632
 
                                             u"d: Deny"))))
633
 
                self.refresh()
634
 
            elif key == u"tab":
635
 
                if self.topwidget.get_focus() is self.logbox:
636
 
                    self.topwidget.set_focus(0)
637
 
                else:
638
 
                    self.topwidget.set_focus(self.logbox)
639
 
                self.refresh()
640
 
            #elif (key == u"end" or key == u"meta >" or key == u"G"
641
 
            #      or key == u">"):
642
 
            #    pass            # xxx end-of-buffer
643
 
            #elif (key == u"home" or key == u"meta <" or key == u"g"
644
 
            #      or key == u"<"):
645
 
            #    pass            # xxx beginning-of-buffer
646
 
            #elif key == u"ctrl e" or key == u"$":
647
 
            #    pass            # xxx move-end-of-line
648
 
            #elif key == u"ctrl a" or key == u"^":
649
 
            #    pass            # xxx move-beginning-of-line
650
 
            #elif key == u"ctrl b" or key == u"meta (" or key == u"h":
651
 
            #    pass            # xxx left
652
 
            #elif key == u"ctrl f" or key == u"meta )" or key == u"l":
653
 
            #    pass            # xxx right
654
 
            #elif key == u"a":
655
 
            #    pass            # scroll up log
656
 
            #elif key == u"z":
657
 
            #    pass            # scroll down log
658
 
            elif self.topwidget.selectable():
659
 
                self.topwidget.keypress(self.size, key)
660
 
                self.refresh()
661
 
        return True
662
 
 
663
 
ui = UserInterface()
664
 
try:
665
 
    ui.run()
666
 
except KeyboardInterrupt:
667
 
    ui.screen.stop()
668
 
except Exception, e:
669
 
    ui.log_message(unicode(e))
670
 
    ui.screen.stop()
671
 
    raise