/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 at bsnet
  • Date: 2010-08-31 18:22:25 UTC
  • mto: (24.1.154 mandos)
  • mto: This revision was merged to the branch mainline in revision 421.
  • Revision ID: teddy@fukt.bsnet.se-20100831182225-sad2cgilj3jeduab
* mandos-monitor (MandosClientWidget): Accept new signal
                                       "NeedApproval".
  (MandosClientWidget.checker_completed): Don't log successful
                                          checkers.
  (MandosClientWidget.checker_started): Don't log.
  (MandosClientWidget.need_approval): New; just log a message.
  (MandosClientWidget.rejected): Take an additional "reason" argument.
  (MandosClientWidget.keypress): Accept "+" and "-" keys to accept or
                                 reject, respectively.

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,2010 Teddy Hogeborn
7
 
# Copyright © 2009,2010 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, unicode_literals
 
4
from __future__ import division, absolute_import, with_statement
26
5
 
27
6
import sys
28
7
import os
42
21
 
43
22
import locale
44
23
 
45
 
locale.setlocale(locale.LC_ALL, '')
 
24
locale.setlocale(locale.LC_ALL, u'')
46
25
 
47
26
import logging
48
27
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
51
30
domain = 'se.bsnet.fukt'
52
31
server_interface = domain + '.Mandos'
53
32
client_interface = domain + '.Mandos.Client'
54
 
version = "1.2.3"
 
33
version = "1.0.15"
55
34
 
56
35
# Always run in monochrome mode
57
36
urwid.curses_display.curses.has_colors = lambda : False
61
40
urwid.curses_display.curses.A_UNDERLINE |= (
62
41
    urwid.curses_display.curses.A_BLINK)
63
42
 
64
 
def isoformat_to_datetime(iso):
65
 
    "Parse an ISO 8601 date string to a datetime.datetime()"
66
 
    if not iso:
67
 
        return None
68
 
    d, t = iso.split("T", 1)
69
 
    year, month, day = d.split("-", 2)
70
 
    hour, minute, second = t.split(":", 2)
71
 
    second, fraction = divmod(float(second), 1)
72
 
    return datetime.datetime(int(year),
73
 
                             int(month),
74
 
                             int(day),
75
 
                             int(hour),
76
 
                             int(minute),
77
 
                             int(second),           # Whole seconds
78
 
                             int(fraction*1000000)) # Microseconds
79
 
 
80
43
class MandosClientPropertyCache(object):
81
44
    """This wraps a Mandos Client D-Bus proxy object, caches the
82
45
    properties and calls a hook function when any of them are
86
49
        self.proxy = proxy_object # Mandos Client proxy object
87
50
        
88
51
        self.properties = dict()
89
 
        self.proxy.connect_to_signal("PropertyChanged",
 
52
        self.proxy.connect_to_signal(u"PropertyChanged",
90
53
                                     self.property_changed,
91
54
                                     client_interface,
92
55
                                     byte_arrays=True)
94
57
        self.properties.update(
95
58
            self.proxy.GetAll(client_interface,
96
59
                              dbus_interface = dbus.PROPERTIES_IFACE))
97
 
 
98
 
        #XXX This break good super behaviour!
99
 
#        super(MandosClientPropertyCache, self).__init__(
100
 
#            *args, **kwargs)
 
60
        super(MandosClientPropertyCache, self).__init__(
 
61
            proxy_object=proxy_object, *args, **kwargs)
101
62
    
102
63
    def property_changed(self, property=None, value=None):
103
64
        """This is called whenever we get a PropertyChanged signal
122
83
        # Logger
123
84
        self.logger = logger
124
85
        
125
 
        self._update_timer_callback_tag = None
126
 
        self._update_timer_callback_lock = 0
127
 
        self.last_checker_failed = False
128
 
        
129
86
        # The widget shown normally
130
 
        self._text_widget = urwid.Text("")
 
87
        self._text_widget = urwid.Text(u"")
131
88
        # The widget shown when we have focus
132
 
        self._focus_text_widget = urwid.Text("")
 
89
        self._focus_text_widget = urwid.Text(u"")
133
90
        super(MandosClientWidget, self).__init__(
134
91
            update_hook=update_hook, delete_hook=delete_hook,
135
92
            *args, **kwargs)
136
93
        self.update()
137
94
        self.opened = False
138
 
        
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",
 
95
        self.proxy.connect_to_signal(u"CheckerCompleted",
158
96
                                     self.checker_completed,
159
97
                                     client_interface,
160
98
                                     byte_arrays=True)
161
 
        self.proxy.connect_to_signal("CheckerStarted",
 
99
        self.proxy.connect_to_signal(u"CheckerStarted",
162
100
                                     self.checker_started,
163
101
                                     client_interface,
164
102
                                     byte_arrays=True)
165
 
        self.proxy.connect_to_signal("GotSecret",
 
103
        self.proxy.connect_to_signal(u"GotSecret",
166
104
                                     self.got_secret,
167
105
                                     client_interface,
168
106
                                     byte_arrays=True)
169
 
        self.proxy.connect_to_signal("NeedApproval",
 
107
        self.proxy.connect_to_signal(u"NeedApproval",
170
108
                                     self.need_approval,
171
109
                                     client_interface,
172
110
                                     byte_arrays=True)
173
 
        self.proxy.connect_to_signal("Rejected",
 
111
        self.proxy.connect_to_signal(u"Rejected",
174
112
                                     self.rejected,
175
113
                                     client_interface,
176
114
                                     byte_arrays=True)
177
115
    
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
 
    def using_timer(self, flag):
185
 
        """Call this method with True or False when timer should be
186
 
        activated or deactivated.
187
 
        """
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:
194
 
            self._update_timer_callback_tag = (gobject.timeout_add
195
 
                                               (1000,
196
 
                                                self.update_timer))
197
 
        elif old and self._update_timer_callback_lock == 0:
198
 
            gobject.source_remove(self._update_timer_callback_tag)
199
 
            self._update_timer_callback_tag = None
200
 
    
201
116
    def checker_completed(self, exitstatus, condition, command):
202
117
        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
 
            self.update()
 
118
            #self.logger(u'Checker for client %s (command "%s")'
 
119
            #            u' was successful'
 
120
            #            % (self.properties[u"name"], command))
210
121
            return
211
 
        # Checker failed
212
 
        if not self.last_checker_failed:
213
 
            self.last_checker_failed = True
214
 
            self.using_timer(True)
215
122
        if os.WIFEXITED(condition):
216
 
            self.logger('Checker for client %s (command "%s")'
217
 
                        ' failed with exit code %s'
218
 
                        % (self.properties["Name"], command,
 
123
            self.logger(u'Checker for client %s (command "%s")'
 
124
                        u' failed with exit code %s'
 
125
                        % (self.properties[u"name"], command,
219
126
                           os.WEXITSTATUS(condition)))
220
 
        elif os.WIFSIGNALED(condition):
221
 
            self.logger('Checker for client %s (command "%s")'
222
 
                        ' was killed by signal %s'
223
 
                        % (self.properties["Name"], command,
 
127
            return
 
128
        if os.WIFSIGNALED(condition):
 
129
            self.logger(u'Checker for client %s (command "%s")'
 
130
                        u' was killed by signal %s'
 
131
                        % (self.properties[u"name"], command,
224
132
                           os.WTERMSIG(condition)))
225
 
        elif os.WCOREDUMP(condition):
226
 
            self.logger('Checker for client %s (command "%s")'
227
 
                        ' dumped core'
228
 
                        % (self.properties["Name"], command))
229
 
        else:
230
 
            self.logger('Checker for client %s completed'
231
 
                        ' mysteriously')
232
 
        self.update()
 
133
            return
 
134
        if os.WCOREDUMP(condition):
 
135
            self.logger(u'Checker for client %s (command "%s")'
 
136
                        u' dumped core'
 
137
                        % (self.properties[u"name"], command))
 
138
        self.logger(u'Checker for client %s completed mysteriously')
233
139
    
234
140
    def checker_started(self, command):
235
 
        #self.logger('Client %s started checker "%s"'
236
 
        #            % (self.properties["Name"], unicode(command)))
 
141
        #self.logger(u'Client %s started checker "%s"'
 
142
        #            % (self.properties[u"name"], unicode(command)))
237
143
        pass
238
144
    
239
145
    def got_secret(self):
240
 
        self.last_checker_failed = False
241
 
        self.logger('Client %s received its secret'
242
 
                    % self.properties["Name"])
 
146
        self.logger(u'Client %s received its secret'
 
147
                    % self.properties[u"name"])
243
148
    
244
149
    def need_approval(self, timeout, default):
245
150
        if not default:
246
 
            message = 'Client %s needs approval within %s seconds'
 
151
            message = u'Client %s needs approval within %s seconds'
247
152
        else:
248
 
            message = 'Client %s will get its secret in %s seconds'
 
153
            message = u'Client %s will get its secret in %s seconds'
249
154
        self.logger(message
250
 
                    % (self.properties["Name"], timeout/1000))
251
 
        self.using_timer(True)
 
155
                    % (self.properties[u"name"], timeout/1000))
252
156
    
253
157
    def rejected(self, reason):
254
 
        self.logger('Client %s was rejected; reason: %s'
255
 
                    % (self.properties["Name"], reason))
 
158
        self.logger(u'Client %s was rejected; reason: %s'
 
159
                    % (self.properties[u"name"], reason))
256
160
    
257
161
    def selectable(self):
258
162
        """Make this a "selectable" widget.
259
163
        This overrides the method from urwid.FlowWidget."""
260
164
        return True
261
165
    
262
 
    def rows(self, maxcolrow, focus=False):
 
166
    def rows(self, (maxcol,), focus=False):
263
167
        """How many rows this widget will occupy might depend on
264
168
        whether we have focus or not.
265
169
        This overrides the method from urwid.FlowWidget"""
266
 
        return self.current_widget(focus).rows(maxcolrow, focus=focus)
 
170
        return self.current_widget(focus).rows((maxcol,), focus=focus)
267
171
    
268
172
    def current_widget(self, focus=False):
269
173
        if focus or self.opened:
273
177
    def update(self):
274
178
        "Called when what is visible on the screen should be updated."
275
179
        # How to add standout mode to a style
276
 
        with_standout = { "normal": "standout",
277
 
                          "bold": "bold-standout",
278
 
                          "underline-blink":
279
 
                              "underline-blink-standout",
280
 
                          "bold-underline-blink":
281
 
                              "bold-underline-blink-standout",
 
180
        with_standout = { u"normal": u"standout",
 
181
                          u"bold": u"bold-standout",
 
182
                          u"underline-blink":
 
183
                              u"underline-blink-standout",
 
184
                          u"bold-underline-blink":
 
185
                              u"bold-underline-blink-standout",
282
186
                          }
283
 
 
 
187
        
284
188
        # Rebuild focus and non-focus widgets using current properties
285
 
 
286
 
        # Base part of a client. Name!
287
 
        base = ('%(name)s: '
288
 
                      % {"name": self.properties["Name"]})
289
 
        if not self.properties["Enabled"]:
290
 
            message = "DISABLED"
291
 
        elif self.properties["ApprovalPending"]:
292
 
            timeout = datetime.timedelta(milliseconds
293
 
                                         = self.properties
294
 
                                         ["ApprovalDelay"])
295
 
            last_approval_request = isoformat_to_datetime(
296
 
                self.properties["LastApprovalRequest"])
297
 
            if last_approval_request is not None:
298
 
                timer = timeout - (datetime.datetime.utcnow()
299
 
                                   - last_approval_request)
300
 
            else:
301
 
                timer = datetime.timedelta()
302
 
            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)
316
 
            message = ('A checker has failed! Time until client'
317
 
                       ' gets disabled: %s'
318
 
                           % unicode(timer).rsplit(".", 1)[0])
319
 
        else:
320
 
            message = "enabled"
321
 
        self._text = "%s%s" % (base, message)
322
 
            
 
189
        self._text = (u'%(name)s: %(enabled)s'
 
190
                      % { u"name": self.properties[u"name"],
 
191
                          u"enabled":
 
192
                              (u"enabled"
 
193
                               if self.properties[u"enabled"]
 
194
                               else u"DISABLED")})
323
195
        if not urwid.supports_unicode():
324
196
            self._text = self._text.encode("ascii", "replace")
325
 
        textlist = [("normal", self._text)]
 
197
        textlist = [(u"normal", self._text)]
326
198
        self._text_widget.set_text(textlist)
327
199
        self._focus_text_widget.set_text([(with_standout[text[0]],
328
200
                                           text[1])
336
208
        if self.update_hook is not None:
337
209
            self.update_hook()
338
210
    
339
 
    def update_timer(self):
340
 
        "called by gobject"
341
 
        self.update()
342
 
        return True             # Keep calling this
343
 
    
344
211
    def delete(self):
345
 
        if self._update_timer_callback_tag is not None:
346
 
            gobject.source_remove(self._update_timer_callback_tag)
347
 
            self._update_timer_callback_tag = None
348
212
        if self.delete_hook is not None:
349
213
            self.delete_hook(self)
350
214
    
351
 
    def render(self, maxcolrow, focus=False):
 
215
    def render(self, (maxcol,), focus=False):
352
216
        """Render differently if we have focus.
353
217
        This overrides the method from urwid.FlowWidget"""
354
 
        return self.current_widget(focus).render(maxcolrow,
 
218
        return self.current_widget(focus).render((maxcol,),
355
219
                                                 focus=focus)
356
220
    
357
 
    def keypress(self, maxcolrow, key):
 
221
    def keypress(self, (maxcol,), key):
358
222
        """Handle keys.
359
223
        This overrides the method from urwid.FlowWidget"""
360
 
        if key == "+":
361
 
            self.proxy.Enable(dbus_interface = client_interface)
362
 
        elif key == "-":
363
 
            self.proxy.Disable(dbus_interface = client_interface)
364
 
        elif key == "a":
365
 
            self.proxy.Approve(dbus.Boolean(True, variant_level=1),
366
 
                               dbus_interface = client_interface)
367
 
        elif key == "d":
368
 
            self.proxy.Approve(dbus.Boolean(False, variant_level=1),
369
 
                                  dbus_interface = client_interface)
370
 
        elif key == "R" or key == "_" or key == "ctrl k":
 
224
        if key == u"e" or key == u"+":
 
225
            self.proxy.Enable()
 
226
        elif key == u"d" or key == u"-":
 
227
            self.proxy.Disable()
 
228
        elif key == u"r" or key == u"_" or key == u"ctrl k":
371
229
            self.server_proxy_object.RemoveClient(self.proxy
372
230
                                                  .object_path)
373
 
        elif key == "s":
374
 
            self.proxy.StartChecker(dbus_interface = client_interface)
375
 
        elif key == "S":
376
 
            self.proxy.StopChecker(dbus_interface = client_interface)
377
 
        elif key == "C":
378
 
            self.proxy.CheckedOK(dbus_interface = client_interface)
 
231
        elif key == u"s":
 
232
            self.proxy.StartChecker()
 
233
        elif key == u"S":
 
234
            self.proxy.StopChecker()
 
235
        elif key == u"C":
 
236
            self.proxy.CheckedOK()
379
237
        # xxx
380
 
#         elif key == "p" or key == "=":
 
238
#         elif key == u"p" or key == "=":
381
239
#             self.proxy.pause()
382
 
#         elif key == "u" or key == ":":
 
240
#         elif key == u"u" or key == ":":
383
241
#             self.proxy.unpause()
384
 
#         elif key == "RET":
 
242
#         elif key == u"RET":
385
243
#             self.open()
 
244
        elif key == u"+":
 
245
            self.proxy.Approve(True)
 
246
        elif key == u"-":
 
247
            self.proxy.Approve(False)
386
248
        else:
387
249
            return key
388
250
    
403
265
    "down" key presses, thus not allowing any containing widgets to
404
266
    use them as an excuse to shift focus away from this widget.
405
267
    """
406
 
    def keypress(self, maxcolrow, key):
407
 
        ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)
408
 
        if ret in ("up", "down"):
 
268
    def keypress(self, (maxcol, maxrow), key):
 
269
        ret = super(ConstrainedListBox, self).keypress((maxcol, maxrow), key)
 
270
        if ret in (u"up", u"down"):
409
271
            return
410
272
        return ret
411
273
 
420
282
        self.screen = urwid.curses_display.Screen()
421
283
        
422
284
        self.screen.register_palette((
423
 
                ("normal",
424
 
                 "default", "default", None),
425
 
                ("bold",
426
 
                 "default", "default", "bold"),
427
 
                ("underline-blink",
428
 
                 "default", "default", "underline"),
429
 
                ("standout",
430
 
                 "default", "default", "standout"),
431
 
                ("bold-underline-blink",
432
 
                 "default", "default", ("bold", "underline")),
433
 
                ("bold-standout",
434
 
                 "default", "default", ("bold", "standout")),
435
 
                ("underline-blink-standout",
436
 
                 "default", "default", ("underline", "standout")),
437
 
                ("bold-underline-blink-standout",
438
 
                 "default", "default", ("bold", "underline",
439
 
                                          "standout")),
 
285
                (u"normal",
 
286
                 u"default", u"default", None),
 
287
                (u"bold",
 
288
                 u"default", u"default", u"bold"),
 
289
                (u"underline-blink",
 
290
                 u"default", u"default", u"underline"),
 
291
                (u"standout",
 
292
                 u"default", u"default", u"standout"),
 
293
                (u"bold-underline-blink",
 
294
                 u"default", u"default", (u"bold", u"underline")),
 
295
                (u"bold-standout",
 
296
                 u"default", u"default", (u"bold", u"standout")),
 
297
                (u"underline-blink-standout",
 
298
                 u"default", u"default", (u"underline", u"standout")),
 
299
                (u"bold-underline-blink-standout",
 
300
                 u"default", u"default", (u"bold", u"underline",
 
301
                                          u"standout")),
440
302
                ))
441
303
        
442
304
        if urwid.supports_unicode():
443
 
            self.divider = "─" # \u2500
444
 
            #self.divider = "━" # \u2501
 
305
            self.divider = u"─" # \u2500
 
306
            #self.divider = u"━" # \u2501
445
307
        else:
446
 
            #self.divider = "-" # \u002d
447
 
            self.divider = "_" # \u005f
 
308
            #self.divider = u"-" # \u002d
 
309
            self.divider = u"_" # \u005f
448
310
        
449
311
        self.screen.start()
450
312
        
464
326
        # This keeps track of whether self.uilist currently has
465
327
        # self.logbox in it or not
466
328
        self.log_visible = True
467
 
        self.log_wrap = "any"
 
329
        self.log_wrap = u"any"
468
330
        
469
331
        self.rebuild()
470
 
        self.log_message_raw(("bold",
471
 
                              "Mandos Monitor version " + version))
472
 
        self.log_message_raw(("bold",
473
 
                              "q: Quit  ?: Help"))
 
332
        self.log_message_raw((u"bold",
 
333
                              u"Mandos Monitor version " + version))
 
334
        self.log_message_raw((u"bold",
 
335
                              u"q: Quit  ?: Help"))
474
336
        
475
337
        self.busname = domain + '.Mandos'
476
338
        self.main_loop = gobject.MainLoop()
477
339
        self.bus = dbus.SystemBus()
478
340
        mandos_dbus_objc = self.bus.get_object(
479
 
            self.busname, "/", follow_name_owner_changes=True)
 
341
            self.busname, u"/", follow_name_owner_changes=True)
480
342
        self.mandos_serv = dbus.Interface(mandos_dbus_objc,
481
343
                                          dbus_interface
482
344
                                          = server_interface)
487
349
            mandos_clients = dbus.Dictionary()
488
350
        
489
351
        (self.mandos_serv
490
 
         .connect_to_signal("ClientRemoved",
 
352
         .connect_to_signal(u"ClientRemoved",
491
353
                            self.find_and_remove_client,
492
354
                            dbus_interface=server_interface,
493
355
                            byte_arrays=True))
494
356
        (self.mandos_serv
495
 
         .connect_to_signal("ClientAdded",
 
357
         .connect_to_signal(u"ClientAdded",
496
358
                            self.add_new_client,
497
359
                            dbus_interface=server_interface,
498
360
                            byte_arrays=True))
499
361
        (self.mandos_serv
500
 
         .connect_to_signal("ClientNotFound",
 
362
         .connect_to_signal(u"ClientNotFound",
501
363
                            self.client_not_found,
502
364
                            dbus_interface=server_interface,
503
365
                            byte_arrays=True))
518
380
                            path=path)
519
381
    
520
382
    def client_not_found(self, fingerprint, address):
521
 
        self.log_message(("Client with address %s and fingerprint %s"
522
 
                          " could not be found" % (address,
 
383
        self.log_message((u"Client with address %s and fingerprint %s"
 
384
                          u" could not be found" % (address,
523
385
                                                    fingerprint)))
524
386
    
525
387
    def rebuild(self):
527
389
        Call this when the widget layout needs to change"""
528
390
        self.uilist = []
529
391
        #self.uilist.append(urwid.ListBox(self.clients))
530
 
        self.uilist.append(urwid.Frame(ConstrainedListBox(self.
531
 
                                                          clients),
 
392
        self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),
532
393
                                       #header=urwid.Divider(),
533
394
                                       header=None,
534
 
                                       footer=
535
 
                                       urwid.Divider(div_char=
536
 
                                                     self.divider)))
 
395
                                       footer=urwid.Divider(div_char=self.divider)))
537
396
        if self.log_visible:
538
397
            self.uilist.append(self.logbox)
539
398
            pass
541
400
    
542
401
    def log_message(self, message):
543
402
        timestamp = datetime.datetime.now().isoformat()
544
 
        self.log_message_raw(timestamp + ": " + message)
 
403
        self.log_message_raw(timestamp + u": " + message)
545
404
    
546
405
    def log_message_raw(self, markup):
547
406
        """Add a log message to the log buffer."""
550
409
            and len(self.log) > self.max_log_length):
551
410
            del self.log[0:len(self.log)-self.max_log_length-1]
552
411
        self.logbox.set_focus(len(self.logbox.body.contents),
553
 
                              coming_from="above")
 
412
                              coming_from=u"above")
554
413
        self.refresh()
555
414
    
556
415
    def toggle_log_display(self):
557
416
        """Toggle visibility of the log buffer."""
558
417
        self.log_visible = not self.log_visible
559
418
        self.rebuild()
560
 
        #self.log_message("Log visibility changed to: "
561
 
        #                 + unicode(self.log_visible))
 
419
        self.log_message(u"Log visibility changed to: "
 
420
                         + unicode(self.log_visible))
562
421
    
563
422
    def change_log_display(self):
564
423
        """Change type of log display.
565
424
        Currently, this toggles wrapping of text lines."""
566
 
        if self.log_wrap == "clip":
567
 
            self.log_wrap = "any"
 
425
        if self.log_wrap == u"clip":
 
426
            self.log_wrap = u"any"
568
427
        else:
569
 
            self.log_wrap = "clip"
 
428
            self.log_wrap = u"clip"
570
429
        for textwidget in self.log:
571
430
            textwidget.set_wrap_mode(self.log_wrap)
572
 
        #self.log_message("Wrap mode: " + self.log_wrap)
 
431
        self.log_message(u"Wrap mode: " + self.log_wrap)
573
432
    
574
433
    def find_and_remove_client(self, path, name):
575
434
        """Find an client from its object path and remove it.
602
461
        if path is None:
603
462
            path = client.proxy.object_path
604
463
        self.clients_dict[path] = client
605
 
        self.clients.sort(None, lambda c: c.properties["Name"])
 
464
        self.clients.sort(None, lambda c: c.properties[u"name"])
606
465
        self.refresh()
607
466
    
608
467
    def remove_client(self, client, path=None):
639
498
    
640
499
    def process_input(self, source, condition):
641
500
        keys = self.screen.get_input()
642
 
        translations = { "ctrl n": "down",      # Emacs
643
 
                         "ctrl p": "up",        # Emacs
644
 
                         "ctrl v": "page down", # Emacs
645
 
                         "meta v": "page up",   # Emacs
646
 
                         " ": "page down",      # less
647
 
                         "f": "page down",      # less
648
 
                         "b": "page up",        # less
649
 
                         "j": "down",           # vi
650
 
                         "k": "up",             # vi
 
501
        translations = { u"ctrl n": u"down",      # Emacs
 
502
                         u"ctrl p": u"up",        # Emacs
 
503
                         u"ctrl v": u"page down", # Emacs
 
504
                         u"meta v": u"page up",   # Emacs
 
505
                         u" ": u"page down",      # less
 
506
                         u"f": u"page down",      # less
 
507
                         u"b": u"page up",        # less
 
508
                         u"j": u"down",           # vi
 
509
                         u"k": u"up",             # vi
651
510
                         }
652
511
        for key in keys:
653
512
            try:
655
514
            except KeyError:    # :-)
656
515
                pass
657
516
            
658
 
            if key == "q" or key == "Q":
 
517
            if key == u"q" or key == u"Q":
659
518
                self.stop()
660
519
                break
661
 
            elif key == "window resize":
 
520
            elif key == u"window resize":
662
521
                self.size = self.screen.get_cols_rows()
663
522
                self.refresh()
664
 
            elif key == "\f":  # Ctrl-L
 
523
            elif key == u"\f":  # Ctrl-L
665
524
                self.refresh()
666
 
            elif key == "l" or key == "D":
 
525
            elif key == u"l" or key == u"D":
667
526
                self.toggle_log_display()
668
527
                self.refresh()
669
 
            elif key == "w" or key == "i":
 
528
            elif key == u"w" or key == u"i":
670
529
                self.change_log_display()
671
530
                self.refresh()
672
 
            elif key == "?" or key == "f1" or key == "esc":
 
531
            elif key == u"?" or key == u"f1" or key == u"esc":
673
532
                if not self.log_visible:
674
533
                    self.log_visible = True
675
534
                    self.rebuild()
676
 
                self.log_message_raw(("bold",
677
 
                                      "  ".
678
 
                                      join(("q: Quit",
679
 
                                            "?: Help",
680
 
                                            "l: Log window toggle",
681
 
                                            "TAB: Switch window",
682
 
                                            "w: Wrap (log)"))))
683
 
                self.log_message_raw(("bold",
684
 
                                      "  "
685
 
                                      .join(("Clients:",
686
 
                                             "+: Enable",
687
 
                                             "-: Disable",
688
 
                                             "R: Remove",
689
 
                                             "s: Start new checker",
690
 
                                             "S: Stop checker",
691
 
                                             "C: Checker OK",
692
 
                                             "a: Approve",
693
 
                                             "d: Deny"))))
 
535
                self.log_message_raw((u"bold",
 
536
                                      u"  ".
 
537
                                      join((u"q: Quit",
 
538
                                            u"?: Help",
 
539
                                            u"l: Log window toggle",
 
540
                                            u"TAB: Switch window",
 
541
                                            u"w: Wrap (log)"))))
 
542
                self.log_message_raw((u"bold",
 
543
                                      u"  "
 
544
                                      .join((u"Clients:",
 
545
                                             u"e: Enable",
 
546
                                             u"d: Disable",
 
547
                                             u"r: Remove",
 
548
                                             u"s: Start new checker",
 
549
                                             u"S: Stop checker",
 
550
                                             u"C: Checker OK"))))
694
551
                self.refresh()
695
 
            elif key == "tab":
 
552
            elif key == u"tab":
696
553
                if self.topwidget.get_focus() is self.logbox:
697
554
                    self.topwidget.set_focus(0)
698
555
                else:
699
556
                    self.topwidget.set_focus(self.logbox)
700
557
                self.refresh()
701
 
            #elif (key == "end" or key == "meta >" or key == "G"
702
 
            #      or key == ">"):
 
558
            #elif (key == u"end" or key == u"meta >" or key == u"G"
 
559
            #      or key == u">"):
703
560
            #    pass            # xxx end-of-buffer
704
 
            #elif (key == "home" or key == "meta <" or key == "g"
705
 
            #      or key == "<"):
 
561
            #elif (key == u"home" or key == u"meta <" or key == u"g"
 
562
            #      or key == u"<"):
706
563
            #    pass            # xxx beginning-of-buffer
707
 
            #elif key == "ctrl e" or key == "$":
 
564
            #elif key == u"ctrl e" or key == u"$":
708
565
            #    pass            # xxx move-end-of-line
709
 
            #elif key == "ctrl a" or key == "^":
 
566
            #elif key == u"ctrl a" or key == u"^":
710
567
            #    pass            # xxx move-beginning-of-line
711
 
            #elif key == "ctrl b" or key == "meta (" or key == "h":
 
568
            #elif key == u"ctrl b" or key == u"meta (" or key == u"h":
712
569
            #    pass            # xxx left
713
 
            #elif key == "ctrl f" or key == "meta )" or key == "l":
 
570
            #elif key == u"ctrl f" or key == u"meta )" or key == u"l":
714
571
            #    pass            # xxx right
715
 
            #elif key == "a":
 
572
            #elif key == u"a":
716
573
            #    pass            # scroll up log
717
 
            #elif key == "z":
 
574
            #elif key == u"z":
718
575
            #    pass            # scroll down log
719
576
            elif self.topwidget.selectable():
720
577
                self.topwidget.keypress(self.size, key)
724
581
ui = UserInterface()
725
582
try:
726
583
    ui.run()
727
 
except KeyboardInterrupt:
728
 
    ui.screen.stop()
729
584
except Exception, e:
730
585
    ui.log_message(unicode(e))
731
586
    ui.screen.stop()