/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: 2014-07-14 21:41:08 UTC
  • Revision ID: teddy@recompile.se-20140714214108-awg7u6gaiy7d40dz
mandos-monitor: New "verbose" mode to see less important log messages.

* mandos-monitor (MandosClientWidget.__init__): Log client creation.
  (MandosClientWidget.checker_completed): Log a successful checker.
  (MandosClientWidget.checker_started): Log starting of a checker.
  (UserInterface.__init__): New optional "log_level" argument.
  (UserInterface.log_message, UserInterface.log_message_raw): Take
                                                              optional
                                                              "level"
                                                              arg.
  (UserInterface.toggle_log_display): Log visibility change.
  (UserInterface.change_log_display): Log wrap mode change.
  (UserInterface.process_input): Show new "v" key in help message and
                                 process "v" key if pressed.
* mandos-monitor.xml (KEYS): Document new "v" key.

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-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.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)
 
63
version = "1.6.6"
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"]), level=0)
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))
 
182
            self.logger('Checker for client {0} (command "{1}")'
 
183
                        ' succeeded'.format(self.properties["Name"],
 
184
                                            command), level=0)
209
185
            self.update()
210
186
            return
211
187
        # Checker failed
212
 
        if not self.last_checker_failed:
213
 
            self.last_checker_failed = True
214
 
            self.using_timer(True)
215
188
        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)))
 
189
            self.logger('Checker for client {0} (command "{1}")'
 
190
                        ' failed with exit code {2}'
 
191
                        .format(self.properties["Name"], command,
 
192
                                os.WEXITSTATUS(condition)))
220
193
        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)))
 
194
            self.logger('Checker for client {0} (command "{1}") was'
 
195
                        ' killed by signal {2}'
 
196
                        .format(self.properties["Name"], command,
 
197
                                os.WTERMSIG(condition)))
225
198
        elif os.WCOREDUMP(condition):
226
 
            self.logger('Checker for client %s (command "%s")'
 
199
            self.logger('Checker for client {0} (command "{1}")'
227
200
                        ' dumped core'
228
 
                        % (self.properties["Name"], command))
 
201
                        .format(self.properties["Name"], command))
229
202
        else:
230
 
            self.logger('Checker for client %s completed'
231
 
                        ' mysteriously')
 
203
            self.logger('Checker for client {0} completed'
 
204
                        ' mysteriously'
 
205
                        .format(self.properties["Name"]))
232
206
        self.update()
233
207
    
234
208
    def checker_started(self, command):
235
 
        #self.logger('Client %s started checker "%s"'
236
 
        #            % (self.properties["Name"], unicode(command)))
237
 
        pass
 
209
        """Server signals that a checker started."""
 
210
        self.logger('Client {0} started checker "{1}"'
 
211
                    .format(self.properties["Name"],
 
212
                            command), level=0)
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
414
404
    """This is the entire user interface - the whole screen
415
405
    with boxes, lists of client widgets, etc.
416
406
    """
417
 
    def __init__(self, max_log_length=1000):
 
407
    def __init__(self, max_log_length=1000, log_level=1):
418
408
        DBusGMainLoop(set_as_default=True)
419
409
        
420
410
        self.screen = urwid.curses_display.Screen()
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():
457
448
        self.log = []
458
449
        self.max_log_length = max_log_length
459
450
        
 
451
        self.log_level = log_level
 
452
        
460
453
        # We keep a reference to the log widget so we can remove it
461
454
        # from the ListWalker without it getting destroyed
462
455
        self.logbox = ConstrainedListBox(self.log)
474
467
        
475
468
        self.busname = domain + '.Mandos'
476
469
        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
470
    
520
471
    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)))
 
472
        self.log_message("Client with address {0} and fingerprint"
 
473
                         " {1} could not be found"
 
474
                         .format(address, fingerprint))
524
475
    
525
476
    def rebuild(self):
526
477
        """This rebuilds the User Interface.
536
487
                                                     self.divider)))
537
488
        if self.log_visible:
538
489
            self.uilist.append(self.logbox)
539
 
            pass
540
490
        self.topwidget = urwid.Pile(self.uilist)
541
491
    
542
 
    def log_message(self, message):
 
492
    def log_message(self, message, level=1):
 
493
        """Log message formatted with timestamp"""
 
494
        if level < self.log_level:
 
495
            return
543
496
        timestamp = datetime.datetime.now().isoformat()
544
 
        self.log_message_raw(timestamp + ": " + message)
 
497
        self.log_message_raw("{0}: {1}".format(timestamp, message),
 
498
                             level=level)
545
499
    
546
 
    def log_message_raw(self, markup):
 
500
    def log_message_raw(self, markup, level=1):
547
501
        """Add a log message to the log buffer."""
 
502
        if level < self.log_level:
 
503
            return
548
504
        self.log.append(urwid.Text(markup, wrap=self.log_wrap))
549
505
        if (self.max_log_length
550
506
            and len(self.log) > self.max_log_length):
557
513
        """Toggle visibility of the log buffer."""
558
514
        self.log_visible = not self.log_visible
559
515
        self.rebuild()
560
 
        #self.log_message("Log visibility changed to: "
561
 
        #                 + unicode(self.log_visible))
 
516
        self.log_message("Log visibility changed to: {0}"
 
517
                         .format(self.log_visible), level=0)
562
518
    
563
519
    def change_log_display(self):
564
520
        """Change type of log display.
569
525
            self.log_wrap = "clip"
570
526
        for textwidget in self.log:
571
527
            textwidget.set_wrap_mode(self.log_wrap)
572
 
        #self.log_message("Wrap mode: " + self.log_wrap)
 
528
        self.log_message("Wrap mode: {0}".format(self.log_wrap),
 
529
                         level=0)
573
530
    
574
531
    def find_and_remove_client(self, path, name):
575
 
        """Find an client from its object path and remove it.
 
532
        """Find a client by its object path and remove it.
576
533
        
577
534
        This is connected to the ClientRemoved signal from the
578
535
        Mandos server object."""
580
537
            client = self.clients_dict[path]
581
538
        except KeyError:
582
539
            # not found?
 
540
            self.log_message("Unknown client {0!r} ({1!r}) removed"
 
541
                             .format(name, path))
583
542
            return
584
 
        self.remove_client(client, path)
 
543
        client.delete()
585
544
    
586
545
    def add_new_client(self, path):
587
546
        client_proxy_object = self.bus.get_object(self.busname, path)
602
561
        if path is None:
603
562
            path = client.proxy.object_path
604
563
        self.clients_dict[path] = client
605
 
        self.clients.sort(None, lambda c: c.properties["Name"])
 
564
        self.clients.sort(key=lambda c: c.properties["Name"])
606
565
        self.refresh()
607
566
    
608
567
    def remove_client(self, client, path=None):
610
569
        if path is None:
611
570
            path = client.proxy.object_path
612
571
        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
572
        self.refresh()
619
573
    
620
574
    def refresh(self):
624
578
    
625
579
    def run(self):
626
580
        """Start the main loop and exit when it's done."""
 
581
        self.bus = dbus.SystemBus()
 
582
        mandos_dbus_objc = self.bus.get_object(
 
583
            self.busname, "/", follow_name_owner_changes=True)
 
584
        self.mandos_serv = dbus.Interface(mandos_dbus_objc,
 
585
                                          dbus_interface
 
586
                                          = server_interface)
 
587
        try:
 
588
            mandos_clients = (self.mandos_serv
 
589
                              .GetAllClientsWithProperties())
 
590
            if not mandos_clients:
 
591
                self.log_message_raw(("bold", "Note: Server has no clients."))
 
592
        except dbus.exceptions.DBusException:
 
593
            self.log_message_raw(("bold", "Note: No Mandos server running."))
 
594
            mandos_clients = dbus.Dictionary()
 
595
        
 
596
        (self.mandos_serv
 
597
         .connect_to_signal("ClientRemoved",
 
598
                            self.find_and_remove_client,
 
599
                            dbus_interface=server_interface,
 
600
                            byte_arrays=True))
 
601
        (self.mandos_serv
 
602
         .connect_to_signal("ClientAdded",
 
603
                            self.add_new_client,
 
604
                            dbus_interface=server_interface,
 
605
                            byte_arrays=True))
 
606
        (self.mandos_serv
 
607
         .connect_to_signal("ClientNotFound",
 
608
                            self.client_not_found,
 
609
                            dbus_interface=server_interface,
 
610
                            byte_arrays=True))
 
611
        for path, client in mandos_clients.items():
 
612
            client_proxy_object = self.bus.get_object(self.busname,
 
613
                                                      path)
 
614
            self.add_client(MandosClientWidget(server_proxy_object
 
615
                                               =self.mandos_serv,
 
616
                                               proxy_object
 
617
                                               =client_proxy_object,
 
618
                                               properties=client,
 
619
                                               update_hook
 
620
                                               =self.refresh,
 
621
                                               delete_hook
 
622
                                               =self.remove_client,
 
623
                                               logger
 
624
                                               =self.log_message),
 
625
                            path=path)
 
626
        
627
627
        self.refresh()
628
628
        self._input_callback_tag = (gobject.io_add_watch
629
629
                                    (sys.stdin.fileno(),
679
679
                                            "?: Help",
680
680
                                            "l: Log window toggle",
681
681
                                            "TAB: Switch window",
682
 
                                            "w: Wrap (log)"))))
 
682
                                            "w: Wrap (log lines)",
 
683
                                            "v: Toggle verbose log",
 
684
                                            ))))
683
685
                self.log_message_raw(("bold",
684
686
                                      "  "
685
687
                                      .join(("Clients:",
698
700
                else:
699
701
                    self.topwidget.set_focus(self.logbox)
700
702
                self.refresh()
 
703
            elif key == "v":
 
704
                if self.log_level == 0:
 
705
                    self.log_level = 1
 
706
                    self.log_message("Verbose mode: Off")
 
707
                else:
 
708
                    self.log_level = 0
 
709
                    self.log_message("Verbose mode: On")
701
710
            #elif (key == "end" or key == "meta >" or key == "G"
702
711
            #      or key == ">"):
703
712
            #    pass            # xxx end-of-buffer
726
735
    ui.run()
727
736
except KeyboardInterrupt:
728
737
    ui.screen.stop()
729
 
except Exception, e:
730
 
    ui.log_message(unicode(e))
 
738
except Exception as e:
 
739
    ui.log_message(str(e))
731
740
    ui.screen.stop()
732
741
    raise