/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: 2013-10-13 15:43:42 UTC
  • Revision ID: teddy@recompile.se-20131013154342-2ztabynqog6xuk0t
* initramfs-unpack: Bug fix: Made executable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
3
3
4
4
# Mandos Monitor - Control and monitor the Mandos server
5
5
6
 
# Copyright © 2009-2011 Teddy Hogeborn
7
 
# Copyright © 2009-2011 Björn Påhlsson
 
6
# Copyright © 2009-2012 Teddy Hogeborn
 
7
# Copyright © 2009-2012 Björn Påhlsson
8
8
9
9
# This program is free software: you can redistribute it and/or modify
10
10
# it under the terms of the GNU General Public License as published by
17
17
#     GNU General Public License for more details.
18
18
19
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/>.
 
20
# along with this program.  If not, see
 
21
# <http://www.gnu.org/licenses/>.
21
22
22
 
# Contact the authors at <mandos@fukt.bsnet.se>.
 
23
# Contact the authors at <mandos@recompile.se>.
23
24
24
25
 
25
 
from __future__ import division, absolute_import, print_function, unicode_literals
 
26
from __future__ import (division, absolute_import, print_function,
 
27
                        unicode_literals)
 
28
try:
 
29
    from future_builtins import *
 
30
except ImportError:
 
31
    pass
26
32
 
27
33
import sys
28
34
import os
34
40
import urwid
35
41
 
36
42
from dbus.mainloop.glib import DBusGMainLoop
37
 
import gobject
 
43
try:
 
44
    import gobject
 
45
except ImportError:
 
46
    from gi.repository import GObject as gobject
38
47
 
39
48
import dbus
40
49
 
41
 
import UserList
42
 
 
43
50
import locale
44
51
 
 
52
if sys.version_info[0] == 2:
 
53
    str = unicode
 
54
 
45
55
locale.setlocale(locale.LC_ALL, '')
46
56
 
47
57
import logging
48
58
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
49
59
 
50
60
# Some useful constants
51
 
domain = 'se.bsnet.fukt'
 
61
domain = 'se.recompile'
52
62
server_interface = domain + '.Mandos'
53
63
client_interface = domain + '.Mandos.Client'
54
 
version = "1.3.0"
55
 
 
56
 
# Always run in monochrome mode
57
 
urwid.curses_display.curses.has_colors = lambda : False
58
 
 
59
 
# Urwid doesn't support blinking, but we want it.  Since we have no
60
 
# use for underline on its own, we make underline also always blink.
61
 
urwid.curses_display.curses.A_UNDERLINE |= (
62
 
    urwid.curses_display.curses.A_BLINK)
 
64
version = "1.6.0"
63
65
 
64
66
def isoformat_to_datetime(iso):
65
67
    "Parse an ISO 8601 date string to a datetime.datetime()"
82
84
    properties and calls a hook function when any of them are
83
85
    changed.
84
86
    """
85
 
    def __init__(self, proxy_object=None, *args, **kwargs):
 
87
    def __init__(self, proxy_object=None, properties=None, **kwargs):
86
88
        self.proxy = proxy_object # Mandos Client proxy object
87
 
        
88
 
        self.properties = dict()
89
 
        self.proxy.connect_to_signal("PropertyChanged",
90
 
                                     self.property_changed,
91
 
                                     client_interface,
92
 
                                     byte_arrays=True)
93
 
        
94
 
        self.properties.update(
95
 
            self.proxy.GetAll(client_interface,
96
 
                              dbus_interface = dbus.PROPERTIES_IFACE))
97
 
 
98
 
        #XXX This break good super behaviour!
99
 
#        super(MandosClientPropertyCache, self).__init__(
100
 
#            *args, **kwargs)
 
89
        self.properties = dict() if properties is None else properties
 
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
        if properties is None:
 
97
            self.properties.update(
 
98
                self.proxy.GetAll(client_interface,
 
99
                                  dbus_interface
 
100
                                  = dbus.PROPERTIES_IFACE))
 
101
        
 
102
        super(MandosClientPropertyCache, self).__init__(**kwargs)
 
103
    
 
104
    def _property_changed(self, property, value):
 
105
        """Helper which takes positional arguments"""
 
106
        return self.property_changed(property=property, value=value)
101
107
    
102
108
    def property_changed(self, property=None, value=None):
103
109
        """This is called whenever we get a PropertyChanged signal
105
111
        """
106
112
        # Update properties dict with new value
107
113
        self.properties[property] = value
 
114
    
 
115
    def delete(self):
 
116
        self.property_changed_match.remove()
108
117
 
109
118
 
110
119
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
112
121
    """
113
122
    
114
123
    def __init__(self, server_proxy_object=None, update_hook=None,
115
 
                 delete_hook=None, logger=None, *args, **kwargs):
 
124
                 delete_hook=None, logger=None, **kwargs):
116
125
        # Called on update
117
126
        self.update_hook = update_hook
118
127
        # Called on delete
123
132
        self.logger = logger
124
133
        
125
134
        self._update_timer_callback_tag = None
126
 
        self._update_timer_callback_lock = 0
127
 
        self.last_checker_failed = False
128
135
        
129
136
        # The widget shown normally
130
137
        self._text_widget = urwid.Text("")
131
138
        # The widget shown when we have focus
132
139
        self._focus_text_widget = urwid.Text("")
133
 
        super(MandosClientWidget, self).__init__(
134
 
            update_hook=update_hook, delete_hook=delete_hook,
135
 
            *args, **kwargs)
 
140
        super(MandosClientWidget, self).__init__(**kwargs)
136
141
        self.update()
137
142
        self.opened = False
138
143
        
139
 
        last_checked_ok = isoformat_to_datetime(self.properties
140
 
                                                ["LastCheckedOK"])
141
 
        if last_checked_ok is None:
142
 
            self.last_checker_failed = True
143
 
        else:
144
 
            self.last_checker_failed = ((datetime.datetime.utcnow()
145
 
                                         - last_checked_ok)
146
 
                                        > datetime.timedelta
147
 
                                        (milliseconds=
148
 
                                         self.properties
149
 
                                         ["Interval"]))
150
 
        
151
 
        if self.last_checker_failed:
152
 
            self.using_timer(True)
153
 
        
154
 
        if self.need_approval:
155
 
            self.using_timer(True)
156
 
        
157
 
        self.proxy.connect_to_signal("CheckerCompleted",
158
 
                                     self.checker_completed,
159
 
                                     client_interface,
160
 
                                     byte_arrays=True)
161
 
        self.proxy.connect_to_signal("CheckerStarted",
162
 
                                     self.checker_started,
163
 
                                     client_interface,
164
 
                                     byte_arrays=True)
165
 
        self.proxy.connect_to_signal("GotSecret",
166
 
                                     self.got_secret,
167
 
                                     client_interface,
168
 
                                     byte_arrays=True)
169
 
        self.proxy.connect_to_signal("NeedApproval",
170
 
                                     self.need_approval,
171
 
                                     client_interface,
172
 
                                     byte_arrays=True)
173
 
        self.proxy.connect_to_signal("Rejected",
174
 
                                     self.rejected,
175
 
                                     client_interface,
176
 
                                     byte_arrays=True)
 
144
        self.match_objects = (
 
145
            self.proxy.connect_to_signal("CheckerCompleted",
 
146
                                         self.checker_completed,
 
147
                                         client_interface,
 
148
                                         byte_arrays=True),
 
149
            self.proxy.connect_to_signal("CheckerStarted",
 
150
                                         self.checker_started,
 
151
                                         client_interface,
 
152
                                         byte_arrays=True),
 
153
            self.proxy.connect_to_signal("GotSecret",
 
154
                                         self.got_secret,
 
155
                                         client_interface,
 
156
                                         byte_arrays=True),
 
157
            self.proxy.connect_to_signal("NeedApproval",
 
158
                                         self.need_approval,
 
159
                                         client_interface,
 
160
                                         byte_arrays=True),
 
161
            self.proxy.connect_to_signal("Rejected",
 
162
                                         self.rejected,
 
163
                                         client_interface,
 
164
                                         byte_arrays=True))
 
165
        #self.logger('Created client {0}'
 
166
        #            .format(self.properties["Name"]))
177
167
    
178
 
    def property_changed(self, property=None, value=None):
179
 
        super(self, MandosClientWidget).property_changed(property,
180
 
                                                         value)
181
 
        if property == "ApprovalPending":
182
 
            using_timer(bool(value))
183
 
        
184
168
    def using_timer(self, flag):
185
169
        """Call this method with True or False when timer should be
186
170
        activated or deactivated.
187
171
        """
188
 
        old = self._update_timer_callback_lock
189
 
        if flag:
190
 
            self._update_timer_callback_lock += 1
191
 
        else:
192
 
            self._update_timer_callback_lock -= 1
193
 
        if old == 0 and self._update_timer_callback_lock:
 
172
        if flag and self._update_timer_callback_tag is None:
 
173
            # Will update the shown timer value every second
194
174
            self._update_timer_callback_tag = (gobject.timeout_add
195
175
                                               (1000,
196
176
                                                self.update_timer))
197
 
        elif old and self._update_timer_callback_lock == 0:
 
177
        elif not (flag or self._update_timer_callback_tag is None):
198
178
            gobject.source_remove(self._update_timer_callback_tag)
199
179
            self._update_timer_callback_tag = None
200
180
    
201
181
    def checker_completed(self, exitstatus, condition, command):
202
182
        if exitstatus == 0:
203
 
            if self.last_checker_failed:
204
 
                self.last_checker_failed = False
205
 
                self.using_timer(False)
206
 
            #self.logger('Checker for client %s (command "%s")'
207
 
            #            ' was successful'
208
 
            #            % (self.properties["Name"], command))
209
183
            self.update()
210
184
            return
211
185
        # Checker failed
212
 
        if not self.last_checker_failed:
213
 
            self.last_checker_failed = True
214
 
            self.using_timer(True)
215
186
        if os.WIFEXITED(condition):
216
 
            self.logger('Checker for client %s (command "%s")'
217
 
                        ' failed with exit code %s'
218
 
                        % (self.properties["Name"], command,
219
 
                           os.WEXITSTATUS(condition)))
 
187
            self.logger('Checker for client {0} (command "{1}")'
 
188
                        ' failed with exit code {2}'
 
189
                        .format(self.properties["Name"], command,
 
190
                                os.WEXITSTATUS(condition)))
220
191
        elif os.WIFSIGNALED(condition):
221
 
            self.logger('Checker for client %s (command "%s")'
222
 
                        ' was killed by signal %s'
223
 
                        % (self.properties["Name"], command,
224
 
                           os.WTERMSIG(condition)))
 
192
            self.logger('Checker for client {0} (command "{1}") was'
 
193
                        ' killed by signal {2}'
 
194
                        .format(self.properties["Name"], command,
 
195
                                os.WTERMSIG(condition)))
225
196
        elif os.WCOREDUMP(condition):
226
 
            self.logger('Checker for client %s (command "%s")'
 
197
            self.logger('Checker for client {0} (command "{1}")'
227
198
                        ' dumped core'
228
 
                        % (self.properties["Name"], command))
 
199
                        .format(self.properties["Name"], command))
229
200
        else:
230
 
            self.logger('Checker for client %s completed'
231
 
                        ' mysteriously')
 
201
            self.logger('Checker for client {0} completed'
 
202
                        ' mysteriously'
 
203
                        .format(self.properties["Name"]))
232
204
        self.update()
233
205
    
234
206
    def checker_started(self, command):
235
 
        #self.logger('Client %s started checker "%s"'
236
 
        #            % (self.properties["Name"], unicode(command)))
 
207
        """Server signals that a checker started. This could be useful
 
208
           to log in the future. """
 
209
        #self.logger('Client {0} started checker "{1}"'
 
210
        #            .format(self.properties["Name"],
 
211
        #                    str(command)))
237
212
        pass
238
213
    
239
214
    def got_secret(self):
240
 
        self.last_checker_failed = False
241
 
        self.logger('Client %s received its secret'
242
 
                    % self.properties["Name"])
 
215
        self.logger('Client {0} received its secret'
 
216
                    .format(self.properties["Name"]))
243
217
    
244
218
    def need_approval(self, timeout, default):
245
219
        if not default:
246
 
            message = 'Client %s needs approval within %s seconds'
 
220
            message = 'Client {0} needs approval within {1} seconds'
247
221
        else:
248
 
            message = 'Client %s will get its secret in %s seconds'
249
 
        self.logger(message
250
 
                    % (self.properties["Name"], timeout/1000))
251
 
        self.using_timer(True)
 
222
            message = 'Client {0} will get its secret in {1} seconds'
 
223
        self.logger(message.format(self.properties["Name"],
 
224
                                   timeout/1000))
252
225
    
253
226
    def rejected(self, reason):
254
 
        self.logger('Client %s was rejected; reason: %s'
255
 
                    % (self.properties["Name"], reason))
 
227
        self.logger('Client {0} was rejected; reason: {1}'
 
228
                    .format(self.properties["Name"], reason))
256
229
    
257
230
    def selectable(self):
258
231
        """Make this a "selectable" widget.
280
253
                          "bold-underline-blink":
281
254
                              "bold-underline-blink-standout",
282
255
                          }
283
 
 
 
256
        
284
257
        # Rebuild focus and non-focus widgets using current properties
285
 
 
 
258
        
286
259
        # Base part of a client. Name!
287
 
        base = ('%(name)s: '
288
 
                      % {"name": self.properties["Name"]})
 
260
        base = '{name}: '.format(name=self.properties["Name"])
289
261
        if not self.properties["Enabled"]:
290
262
            message = "DISABLED"
 
263
            self.using_timer(False)
291
264
        elif self.properties["ApprovalPending"]:
292
265
            timeout = datetime.timedelta(milliseconds
293
266
                                         = self.properties
295
268
            last_approval_request = isoformat_to_datetime(
296
269
                self.properties["LastApprovalRequest"])
297
270
            if last_approval_request is not None:
298
 
                timer = timeout - (datetime.datetime.utcnow()
299
 
                                   - last_approval_request)
 
271
                timer = max(timeout - (datetime.datetime.utcnow()
 
272
                                       - last_approval_request),
 
273
                            datetime.timedelta())
300
274
            else:
301
275
                timer = datetime.timedelta()
302
276
            if self.properties["ApprovedByDefault"]:
303
 
                message = "Approval in %s. (d)eny?"
304
 
            else:
305
 
                message = "Denial in %s. (a)pprove?"
306
 
            message = message % unicode(timer).rsplit(".", 1)[0]
307
 
        elif self.last_checker_failed:
308
 
            timeout = datetime.timedelta(milliseconds
309
 
                                         = self.properties
310
 
                                         ["Timeout"])
311
 
            last_ok = isoformat_to_datetime(
312
 
                max((self.properties["LastCheckedOK"]
313
 
                     or self.properties["Created"]),
314
 
                    self.properties["LastEnabled"]))
315
 
            timer = timeout - (datetime.datetime.utcnow() - last_ok)
 
277
                message = "Approval in {0}. (d)eny?"
 
278
            else:
 
279
                message = "Denial in {0}. (a)pprove?"
 
280
            message = message.format(str(timer).rsplit(".", 1)[0])
 
281
            self.using_timer(True)
 
282
        elif self.properties["LastCheckerStatus"] != 0:
 
283
            # When checker has failed, show timer until client expires
 
284
            expires = self.properties["Expires"]
 
285
            if expires == "":
 
286
                timer = datetime.timedelta(0)
 
287
            else:
 
288
                expires = (datetime.datetime.strptime
 
289
                           (expires, '%Y-%m-%dT%H:%M:%S.%f'))
 
290
                timer = max(expires - datetime.datetime.utcnow(),
 
291
                            datetime.timedelta())
316
292
            message = ('A checker has failed! Time until client'
317
 
                       ' gets disabled: %s'
318
 
                           % unicode(timer).rsplit(".", 1)[0])
 
293
                       ' gets disabled: {0}'
 
294
                       .format(str(timer).rsplit(".", 1)[0]))
 
295
            self.using_timer(True)
319
296
        else:
320
297
            message = "enabled"
321
 
        self._text = "%s%s" % (base, message)
322
 
            
 
298
            self.using_timer(False)
 
299
        self._text = "{0}{1}".format(base, message)
 
300
        
323
301
        if not urwid.supports_unicode():
324
302
            self._text = self._text.encode("ascii", "replace")
325
303
        textlist = [("normal", self._text)]
337
315
            self.update_hook()
338
316
    
339
317
    def update_timer(self):
340
 
        "called by gobject"
 
318
        """called by gobject. Will indefinitely loop until
 
319
        gobject.source_remove() on tag is called"""
341
320
        self.update()
342
321
        return True             # Keep calling this
343
322
    
344
 
    def delete(self):
 
323
    def delete(self, **kwargs):
345
324
        if self._update_timer_callback_tag is not None:
346
325
            gobject.source_remove(self._update_timer_callback_tag)
347
326
            self._update_timer_callback_tag = None
 
327
        for match in self.match_objects:
 
328
            match.remove()
 
329
        self.match_objects = ()
348
330
        if self.delete_hook is not None:
349
331
            self.delete_hook(self)
 
332
        return super(MandosClientWidget, self).delete(**kwargs)
350
333
    
351
334
    def render(self, maxcolrow, focus=False):
352
335
        """Render differently if we have focus.
394
377
        else:
395
378
            return key
396
379
    
397
 
    def property_changed(self, property=None, value=None,
398
 
                         *args, **kwargs):
 
380
    def property_changed(self, property=None, **kwargs):
399
381
        """Call self.update() if old value is not new value.
400
382
        This overrides the method from MandosClientPropertyCache"""
401
 
        property_name = unicode(property)
 
383
        property_name = str(property)
402
384
        old_value = self.properties.get(property_name)
403
385
        super(MandosClientWidget, self).property_changed(
404
 
            property=property, value=value, *args, **kwargs)
 
386
            property=property, **kwargs)
405
387
        if self.properties.get(property_name) != old_value:
406
388
            self.update()
407
389
 
411
393
    "down" key presses, thus not allowing any containing widgets to
412
394
    use them as an excuse to shift focus away from this widget.
413
395
    """
414
 
    def keypress(self, maxcolrow, key):
415
 
        ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)
 
396
    def keypress(self, *args, **kwargs):
 
397
        ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
416
398
        if ret in ("up", "down"):
417
399
            return
418
400
        return ret
431
413
                ("normal",
432
414
                 "default", "default", None),
433
415
                ("bold",
434
 
                 "default", "default", "bold"),
 
416
                 "bold", "default", "bold"),
435
417
                ("underline-blink",
436
 
                 "default", "default", "underline"),
 
418
                 "underline,blink", "default", "underline,blink"),
437
419
                ("standout",
438
 
                 "default", "default", "standout"),
 
420
                 "standout", "default", "standout"),
439
421
                ("bold-underline-blink",
440
 
                 "default", "default", ("bold", "underline")),
 
422
                 "bold,underline,blink", "default", "bold,underline,blink"),
441
423
                ("bold-standout",
442
 
                 "default", "default", ("bold", "standout")),
 
424
                 "bold,standout", "default", "bold,standout"),
443
425
                ("underline-blink-standout",
444
 
                 "default", "default", ("underline", "standout")),
 
426
                 "underline,blink,standout", "default",
 
427
                 "underline,blink,standout"),
445
428
                ("bold-underline-blink-standout",
446
 
                 "default", "default", ("bold", "underline",
447
 
                                          "standout")),
 
429
                 "bold,underline,blink,standout", "default",
 
430
                 "bold,underline,blink,standout"),
448
431
                ))
449
432
        
450
433
        if urwid.supports_unicode():
482
465
        
483
466
        self.busname = domain + '.Mandos'
484
467
        self.main_loop = gobject.MainLoop()
485
 
        self.bus = dbus.SystemBus()
486
 
        mandos_dbus_objc = self.bus.get_object(
487
 
            self.busname, "/", follow_name_owner_changes=True)
488
 
        self.mandos_serv = dbus.Interface(mandos_dbus_objc,
489
 
                                          dbus_interface
490
 
                                          = server_interface)
491
 
        try:
492
 
            mandos_clients = (self.mandos_serv
493
 
                              .GetAllClientsWithProperties())
494
 
        except dbus.exceptions.DBusException:
495
 
            mandos_clients = dbus.Dictionary()
496
 
        
497
 
        (self.mandos_serv
498
 
         .connect_to_signal("ClientRemoved",
499
 
                            self.find_and_remove_client,
500
 
                            dbus_interface=server_interface,
501
 
                            byte_arrays=True))
502
 
        (self.mandos_serv
503
 
         .connect_to_signal("ClientAdded",
504
 
                            self.add_new_client,
505
 
                            dbus_interface=server_interface,
506
 
                            byte_arrays=True))
507
 
        (self.mandos_serv
508
 
         .connect_to_signal("ClientNotFound",
509
 
                            self.client_not_found,
510
 
                            dbus_interface=server_interface,
511
 
                            byte_arrays=True))
512
 
        for path, client in mandos_clients.iteritems():
513
 
            client_proxy_object = self.bus.get_object(self.busname,
514
 
                                                      path)
515
 
            self.add_client(MandosClientWidget(server_proxy_object
516
 
                                               =self.mandos_serv,
517
 
                                               proxy_object
518
 
                                               =client_proxy_object,
519
 
                                               properties=client,
520
 
                                               update_hook
521
 
                                               =self.refresh,
522
 
                                               delete_hook
523
 
                                               =self.remove_client,
524
 
                                               logger
525
 
                                               =self.log_message),
526
 
                            path=path)
527
468
    
528
469
    def client_not_found(self, fingerprint, address):
529
 
        self.log_message(("Client with address %s and fingerprint %s"
530
 
                          " could not be found" % (address,
531
 
                                                    fingerprint)))
 
470
        self.log_message("Client with address {0} and fingerprint"
 
471
                         " {1} could not be found"
 
472
                         .format(address, fingerprint))
532
473
    
533
474
    def rebuild(self):
534
475
        """This rebuilds the User Interface.
544
485
                                                     self.divider)))
545
486
        if self.log_visible:
546
487
            self.uilist.append(self.logbox)
547
 
            pass
548
488
        self.topwidget = urwid.Pile(self.uilist)
549
489
    
550
490
    def log_message(self, message):
 
491
        """Log message formatted with timestamp"""
551
492
        timestamp = datetime.datetime.now().isoformat()
552
493
        self.log_message_raw(timestamp + ": " + message)
553
494
    
566
507
        self.log_visible = not self.log_visible
567
508
        self.rebuild()
568
509
        #self.log_message("Log visibility changed to: "
569
 
        #                 + unicode(self.log_visible))
 
510
        #                 + str(self.log_visible))
570
511
    
571
512
    def change_log_display(self):
572
513
        """Change type of log display.
580
521
        #self.log_message("Wrap mode: " + self.log_wrap)
581
522
    
582
523
    def find_and_remove_client(self, path, name):
583
 
        """Find an client from its object path and remove it.
 
524
        """Find a client by its object path and remove it.
584
525
        
585
526
        This is connected to the ClientRemoved signal from the
586
527
        Mandos server object."""
588
529
            client = self.clients_dict[path]
589
530
        except KeyError:
590
531
            # not found?
 
532
            self.log_message("Unknown client {0!r} ({1!r}) removed"
 
533
                             .format(name, path))
591
534
            return
592
 
        self.remove_client(client, path)
 
535
        client.delete()
593
536
    
594
537
    def add_new_client(self, path):
595
538
        client_proxy_object = self.bus.get_object(self.busname, path)
610
553
        if path is None:
611
554
            path = client.proxy.object_path
612
555
        self.clients_dict[path] = client
613
 
        self.clients.sort(None, lambda c: c.properties["Name"])
 
556
        self.clients.sort(key=lambda c: c.properties["Name"])
614
557
        self.refresh()
615
558
    
616
559
    def remove_client(self, client, path=None):
618
561
        if path is None:
619
562
            path = client.proxy.object_path
620
563
        del self.clients_dict[path]
621
 
        if not self.clients_dict:
622
 
            # Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
623
 
            # is completely emptied, we need to recreate it.
624
 
            self.clients = urwid.SimpleListWalker([])
625
 
            self.rebuild()
626
564
        self.refresh()
627
565
    
628
566
    def refresh(self):
632
570
    
633
571
    def run(self):
634
572
        """Start the main loop and exit when it's done."""
 
573
        self.bus = dbus.SystemBus()
 
574
        mandos_dbus_objc = self.bus.get_object(
 
575
            self.busname, "/", follow_name_owner_changes=True)
 
576
        self.mandos_serv = dbus.Interface(mandos_dbus_objc,
 
577
                                          dbus_interface
 
578
                                          = server_interface)
 
579
        try:
 
580
            mandos_clients = (self.mandos_serv
 
581
                              .GetAllClientsWithProperties())
 
582
            if not mandos_clients:
 
583
                self.log_message_raw(("bold", "Note: Server has no clients."))
 
584
        except dbus.exceptions.DBusException:
 
585
            self.log_message_raw(("bold", "Note: No Mandos server running."))
 
586
            mandos_clients = dbus.Dictionary()
 
587
        
 
588
        (self.mandos_serv
 
589
         .connect_to_signal("ClientRemoved",
 
590
                            self.find_and_remove_client,
 
591
                            dbus_interface=server_interface,
 
592
                            byte_arrays=True))
 
593
        (self.mandos_serv
 
594
         .connect_to_signal("ClientAdded",
 
595
                            self.add_new_client,
 
596
                            dbus_interface=server_interface,
 
597
                            byte_arrays=True))
 
598
        (self.mandos_serv
 
599
         .connect_to_signal("ClientNotFound",
 
600
                            self.client_not_found,
 
601
                            dbus_interface=server_interface,
 
602
                            byte_arrays=True))
 
603
        for path, client in mandos_clients.items():
 
604
            client_proxy_object = self.bus.get_object(self.busname,
 
605
                                                      path)
 
606
            self.add_client(MandosClientWidget(server_proxy_object
 
607
                                               =self.mandos_serv,
 
608
                                               proxy_object
 
609
                                               =client_proxy_object,
 
610
                                               properties=client,
 
611
                                               update_hook
 
612
                                               =self.refresh,
 
613
                                               delete_hook
 
614
                                               =self.remove_client,
 
615
                                               logger
 
616
                                               =self.log_message),
 
617
                            path=path)
 
618
        
635
619
        self.refresh()
636
620
        self._input_callback_tag = (gobject.io_add_watch
637
621
                                    (sys.stdin.fileno(),
734
718
    ui.run()
735
719
except KeyboardInterrupt:
736
720
    ui.screen.stop()
737
 
except Exception, e:
738
 
    ui.log_message(unicode(e))
 
721
except Exception as e:
 
722
    ui.log_message(str(e))
739
723
    ui.screen.stop()
740
724
    raise