/mandos/release

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/release

« back to all changes in this revision

Viewing changes to mandos-monitor

  • Committer: Teddy Hogeborn
  • Date: 2014-03-10 07:04:09 UTC
  • mto: (237.7.272 trunk)
  • mto: This revision was merged to the branch mainline in revision 311.
  • Revision ID: teddy@recompile.se-20140310070409-ho6p1wrnpopi2ny1
White space fix: change "if (" to "if(" in C code.

* plugins.d/askpass-fifo.c (error_plus): White space fix.
* plugins.d/password-prompt.c (error_plus, conflict_detection,
                               main): - '' -
* plugins.d/plymouth.c (error_plus, exec_and_wait, get_pid): - '' -
* plugins.d/splashy.c (error_plus): - '' -
* plugins.d/usplash.c (error_plus): - '' -

Show diffs side-by-side

added added

removed removed

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