/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: 2009-11-09 05:10:35 UTC
  • Revision ID: teddy@fukt.bsnet.se-20091109051035-zcmvuhioo9gjs0cb
* mandos-monitor (MandosClientPropertyCache): Remove conversion of
                                              D-Bus types to native
                                              Python types.
  (MandosClientPropertyCache.type_map): Removed attribute.
  (MandosClientPropertyCache.conversion): Removed method.
  (ConstrainedListBox): New; a ListBox which will keep the focus.
  (UserInterface.__init__): Take new argument "max_log_length".
  (UserInterface.divider, UserInterface.log,
  UserInterface.max_log_length, UserInterface.logbox,
  UserInterface.log_visible, UserInterface.log_wrap): New attributes.
  (UserInterface.rebuild, UserInterface.log_message,
  UserInterface.toggle_log_display, UserInterface.change_log_display):
  New methods.
  (UserInterface.remove_client): Bug fix: Eliminate double client
                                 listing when an empty list gets a
                                 ClientAdded signal.
  (UserInterface.process_input): Add more key translations.

Show diffs side-by-side

added added

removed removed

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