/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-24 20:38:44 UTC
  • mto: This revision was merged to the branch mainline in revision 635.
  • Revision ID: teddy@recompile.se-20131024203844-j0y0ir6vnlj9mkix
Tags: version-1.6.2-1
http://bugs.debian.org/702120
* Makefile (version): Changed to "1.6.2".
* NEWS (Version 1.6.2): New entry.
* debian/changelog (1.6.2-1): - '' -

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-2013 Teddy Hogeborn
 
7
# Copyright © 2009-2013 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.2.3"
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.2"
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.
358
341
        """Handle keys.
359
342
        This overrides the method from urwid.FlowWidget"""
360
343
        if key == "+":
361
 
            self.proxy.Enable(dbus_interface = client_interface)
 
344
            self.proxy.Enable(dbus_interface = client_interface,
 
345
                              ignore_reply=True)
362
346
        elif key == "-":
363
 
            self.proxy.Disable(dbus_interface = client_interface)
 
347
            self.proxy.Disable(dbus_interface = client_interface,
 
348
                               ignore_reply=True)
364
349
        elif key == "a":
365
350
            self.proxy.Approve(dbus.Boolean(True, variant_level=1),
366
 
                               dbus_interface = client_interface)
 
351
                               dbus_interface = client_interface,
 
352
                               ignore_reply=True)
367
353
        elif key == "d":
368
354
            self.proxy.Approve(dbus.Boolean(False, variant_level=1),
369
 
                                  dbus_interface = client_interface)
 
355
                                  dbus_interface = client_interface,
 
356
                               ignore_reply=True)
370
357
        elif key == "R" or key == "_" or key == "ctrl k":
371
358
            self.server_proxy_object.RemoveClient(self.proxy
372
 
                                                  .object_path)
 
359
                                                  .object_path,
 
360
                                                  ignore_reply=True)
373
361
        elif key == "s":
374
 
            self.proxy.StartChecker(dbus_interface = client_interface)
 
362
            self.proxy.StartChecker(dbus_interface = client_interface,
 
363
                                    ignore_reply=True)
375
364
        elif key == "S":
376
 
            self.proxy.StopChecker(dbus_interface = client_interface)
 
365
            self.proxy.StopChecker(dbus_interface = client_interface,
 
366
                                   ignore_reply=True)
377
367
        elif key == "C":
378
 
            self.proxy.CheckedOK(dbus_interface = client_interface)
 
368
            self.proxy.CheckedOK(dbus_interface = client_interface,
 
369
                                 ignore_reply=True)
379
370
        # xxx
380
371
#         elif key == "p" or key == "=":
381
372
#             self.proxy.pause()
386
377
        else:
387
378
            return key
388
379
    
389
 
    def property_changed(self, property=None, value=None,
390
 
                         *args, **kwargs):
 
380
    def property_changed(self, property=None, **kwargs):
391
381
        """Call self.update() if old value is not new value.
392
382
        This overrides the method from MandosClientPropertyCache"""
393
 
        property_name = unicode(property)
 
383
        property_name = str(property)
394
384
        old_value = self.properties.get(property_name)
395
385
        super(MandosClientWidget, self).property_changed(
396
 
            property=property, value=value, *args, **kwargs)
 
386
            property=property, **kwargs)
397
387
        if self.properties.get(property_name) != old_value:
398
388
            self.update()
399
389
 
403
393
    "down" key presses, thus not allowing any containing widgets to
404
394
    use them as an excuse to shift focus away from this widget.
405
395
    """
406
 
    def keypress(self, maxcolrow, key):
407
 
        ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)
 
396
    def keypress(self, *args, **kwargs):
 
397
        ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
408
398
        if ret in ("up", "down"):
409
399
            return
410
400
        return ret
423
413
                ("normal",
424
414
                 "default", "default", None),
425
415
                ("bold",
426
 
                 "default", "default", "bold"),
 
416
                 "bold", "default", "bold"),
427
417
                ("underline-blink",
428
 
                 "default", "default", "underline"),
 
418
                 "underline,blink", "default", "underline,blink"),
429
419
                ("standout",
430
 
                 "default", "default", "standout"),
 
420
                 "standout", "default", "standout"),
431
421
                ("bold-underline-blink",
432
 
                 "default", "default", ("bold", "underline")),
 
422
                 "bold,underline,blink", "default", "bold,underline,blink"),
433
423
                ("bold-standout",
434
 
                 "default", "default", ("bold", "standout")),
 
424
                 "bold,standout", "default", "bold,standout"),
435
425
                ("underline-blink-standout",
436
 
                 "default", "default", ("underline", "standout")),
 
426
                 "underline,blink,standout", "default",
 
427
                 "underline,blink,standout"),
437
428
                ("bold-underline-blink-standout",
438
 
                 "default", "default", ("bold", "underline",
439
 
                                          "standout")),
 
429
                 "bold,underline,blink,standout", "default",
 
430
                 "bold,underline,blink,standout"),
440
431
                ))
441
432
        
442
433
        if urwid.supports_unicode():
474
465
        
475
466
        self.busname = domain + '.Mandos'
476
467
        self.main_loop = gobject.MainLoop()
477
 
        self.bus = dbus.SystemBus()
478
 
        mandos_dbus_objc = self.bus.get_object(
479
 
            self.busname, "/", follow_name_owner_changes=True)
480
 
        self.mandos_serv = dbus.Interface(mandos_dbus_objc,
481
 
                                          dbus_interface
482
 
                                          = server_interface)
483
 
        try:
484
 
            mandos_clients = (self.mandos_serv
485
 
                              .GetAllClientsWithProperties())
486
 
        except dbus.exceptions.DBusException:
487
 
            mandos_clients = dbus.Dictionary()
488
 
        
489
 
        (self.mandos_serv
490
 
         .connect_to_signal("ClientRemoved",
491
 
                            self.find_and_remove_client,
492
 
                            dbus_interface=server_interface,
493
 
                            byte_arrays=True))
494
 
        (self.mandos_serv
495
 
         .connect_to_signal("ClientAdded",
496
 
                            self.add_new_client,
497
 
                            dbus_interface=server_interface,
498
 
                            byte_arrays=True))
499
 
        (self.mandos_serv
500
 
         .connect_to_signal("ClientNotFound",
501
 
                            self.client_not_found,
502
 
                            dbus_interface=server_interface,
503
 
                            byte_arrays=True))
504
 
        for path, client in mandos_clients.iteritems():
505
 
            client_proxy_object = self.bus.get_object(self.busname,
506
 
                                                      path)
507
 
            self.add_client(MandosClientWidget(server_proxy_object
508
 
                                               =self.mandos_serv,
509
 
                                               proxy_object
510
 
                                               =client_proxy_object,
511
 
                                               properties=client,
512
 
                                               update_hook
513
 
                                               =self.refresh,
514
 
                                               delete_hook
515
 
                                               =self.remove_client,
516
 
                                               logger
517
 
                                               =self.log_message),
518
 
                            path=path)
519
468
    
520
469
    def client_not_found(self, fingerprint, address):
521
 
        self.log_message(("Client with address %s and fingerprint %s"
522
 
                          " could not be found" % (address,
523
 
                                                    fingerprint)))
 
470
        self.log_message("Client with address {0} and fingerprint"
 
471
                         " {1} could not be found"
 
472
                         .format(address, fingerprint))
524
473
    
525
474
    def rebuild(self):
526
475
        """This rebuilds the User Interface.
536
485
                                                     self.divider)))
537
486
        if self.log_visible:
538
487
            self.uilist.append(self.logbox)
539
 
            pass
540
488
        self.topwidget = urwid.Pile(self.uilist)
541
489
    
542
490
    def log_message(self, message):
 
491
        """Log message formatted with timestamp"""
543
492
        timestamp = datetime.datetime.now().isoformat()
544
493
        self.log_message_raw(timestamp + ": " + message)
545
494
    
558
507
        self.log_visible = not self.log_visible
559
508
        self.rebuild()
560
509
        #self.log_message("Log visibility changed to: "
561
 
        #                 + unicode(self.log_visible))
 
510
        #                 + str(self.log_visible))
562
511
    
563
512
    def change_log_display(self):
564
513
        """Change type of log display.
572
521
        #self.log_message("Wrap mode: " + self.log_wrap)
573
522
    
574
523
    def find_and_remove_client(self, path, name):
575
 
        """Find an client from its object path and remove it.
 
524
        """Find a client by its object path and remove it.
576
525
        
577
526
        This is connected to the ClientRemoved signal from the
578
527
        Mandos server object."""
580
529
            client = self.clients_dict[path]
581
530
        except KeyError:
582
531
            # not found?
 
532
            self.log_message("Unknown client {0!r} ({1!r}) removed"
 
533
                             .format(name, path))
583
534
            return
584
 
        self.remove_client(client, path)
 
535
        client.delete()
585
536
    
586
537
    def add_new_client(self, path):
587
538
        client_proxy_object = self.bus.get_object(self.busname, path)
602
553
        if path is None:
603
554
            path = client.proxy.object_path
604
555
        self.clients_dict[path] = client
605
 
        self.clients.sort(None, lambda c: c.properties["Name"])
 
556
        self.clients.sort(key=lambda c: c.properties["Name"])
606
557
        self.refresh()
607
558
    
608
559
    def remove_client(self, client, path=None):
610
561
        if path is None:
611
562
            path = client.proxy.object_path
612
563
        del self.clients_dict[path]
613
 
        if not self.clients_dict:
614
 
            # Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
615
 
            # is completely emptied, we need to recreate it.
616
 
            self.clients = urwid.SimpleListWalker([])
617
 
            self.rebuild()
618
564
        self.refresh()
619
565
    
620
566
    def refresh(self):
624
570
    
625
571
    def run(self):
626
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
        
627
619
        self.refresh()
628
620
        self._input_callback_tag = (gobject.io_add_watch
629
621
                                    (sys.stdin.fileno(),
726
718
    ui.run()
727
719
except KeyboardInterrupt:
728
720
    ui.screen.stop()
729
 
except Exception, e:
730
 
    ui.log_message(unicode(e))
 
721
except Exception as e:
 
722
    ui.log_message(str(e))
731
723
    ui.screen.stop()
732
724
    raise