/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: 2011-09-18 15:03:26 UTC
  • Revision ID: teddy@fukt.bsnet.se-20110918150326-tj4zz5qv0cv54we3
* debian/control: Fix language for lintian.

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