/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: Björn Påhlsson
  • Date: 2010-09-09 22:06:10 UTC
  • mto: (237.4.3 mandos-release)
  • mto: This revision was merged to the branch mainline in revision 421.
  • Revision ID: belorn@fukt.bsnet.se-20100909220610-fcpkaykznlq22oaw
minor debug info for plugin-runner.
Commit before merge

Show diffs side-by-side

added added

removed removed

Lines of Context:
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, 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.3.0"
 
33
version = "1.0.15"
55
34
 
56
35
# Always run in monochrome mode
57
36
urwid.curses_display.curses.has_colors = lambda : False
65
44
    "Parse an ISO 8601 date string to a datetime.datetime()"
66
45
    if not iso:
67
46
        return None
68
 
    d, t = iso.split("T", 1)
69
 
    year, month, day = d.split("-", 2)
70
 
    hour, minute, second = t.split(":", 2)
 
47
    d, t = iso.split(u"T", 1)
 
48
    year, month, day = d.split(u"-", 2)
 
49
    hour, minute, second = t.split(u":", 2)
71
50
    second, fraction = divmod(float(second), 1)
72
51
    return datetime.datetime(int(year),
73
52
                             int(month),
86
65
        self.proxy = proxy_object # Mandos Client proxy object
87
66
        
88
67
        self.properties = dict()
89
 
        self.proxy.connect_to_signal("PropertyChanged",
 
68
        self.proxy.connect_to_signal(u"PropertyChanged",
90
69
                                     self.property_changed,
91
70
                                     client_interface,
92
71
                                     byte_arrays=True)
123
102
        self.logger = logger
124
103
        
125
104
        self._update_timer_callback_tag = None
126
 
        self._update_timer_callback_lock = 0
127
105
        self.last_checker_failed = False
128
106
        
129
107
        # The widget shown normally
130
 
        self._text_widget = urwid.Text("")
 
108
        self._text_widget = urwid.Text(u"")
131
109
        # The widget shown when we have focus
132
 
        self._focus_text_widget = urwid.Text("")
 
110
        self._focus_text_widget = urwid.Text(u"")
133
111
        super(MandosClientWidget, self).__init__(
134
112
            update_hook=update_hook, delete_hook=delete_hook,
135
113
            *args, **kwargs)
136
114
        self.update()
137
115
        self.opened = False
138
 
        
 
116
        self.proxy.connect_to_signal(u"CheckerCompleted",
 
117
                                     self.checker_completed,
 
118
                                     client_interface,
 
119
                                     byte_arrays=True)
 
120
        self.proxy.connect_to_signal(u"CheckerStarted",
 
121
                                     self.checker_started,
 
122
                                     client_interface,
 
123
                                     byte_arrays=True)
 
124
        self.proxy.connect_to_signal(u"GotSecret",
 
125
                                     self.got_secret,
 
126
                                     client_interface,
 
127
                                     byte_arrays=True)
 
128
        self.proxy.connect_to_signal(u"NeedApproval",
 
129
                                     self.need_approval,
 
130
                                     client_interface,
 
131
                                     byte_arrays=True)
 
132
        self.proxy.connect_to_signal(u"Rejected",
 
133
                                     self.rejected,
 
134
                                     client_interface,
 
135
                                     byte_arrays=True)
139
136
        last_checked_ok = isoformat_to_datetime(self.properties
140
 
                                                ["LastCheckedOK"])
 
137
                                                ["last_checked_ok"])
141
138
        if last_checked_ok is None:
142
139
            self.last_checker_failed = True
143
140
        else:
145
142
                                         - last_checked_ok)
146
143
                                        > datetime.timedelta
147
144
                                        (milliseconds=
148
 
                                         self.properties
149
 
                                         ["Interval"]))
150
 
        
 
145
                                         self.properties["interval"]))
151
146
        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)
177
 
    
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
147
            self._update_timer_callback_tag = (gobject.timeout_add
195
148
                                               (1000,
196
149
                                                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
150
    
201
151
    def checker_completed(self, exitstatus, condition, command):
202
152
        if exitstatus == 0:
203
153
            if self.last_checker_failed:
204
154
                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))
 
155
                gobject.source_remove(self._update_timer_callback_tag)
 
156
                self._update_timer_callback_tag = None
 
157
            self.logger(u'Checker for client %s (command "%s")'
 
158
                        u' was successful'
 
159
                        % (self.properties[u"name"], command))
209
160
            self.update()
210
161
            return
211
162
        # Checker failed
212
163
        if not self.last_checker_failed:
213
164
            self.last_checker_failed = True
214
 
            self.using_timer(True)
 
165
            self._update_timer_callback_tag = (gobject.timeout_add
 
166
                                               (1000,
 
167
                                                self.update_timer))
215
168
        if os.WIFEXITED(condition):
216
 
            self.logger('Checker for client %s (command "%s")'
217
 
                        ' failed with exit code %s'
218
 
                        % (self.properties["Name"], command,
 
169
            self.logger(u'Checker for client %s (command "%s")'
 
170
                        u' failed with exit code %s'
 
171
                        % (self.properties[u"name"], command,
219
172
                           os.WEXITSTATUS(condition)))
220
173
        elif os.WIFSIGNALED(condition):
221
 
            self.logger('Checker for client %s (command "%s")'
222
 
                        ' was killed by signal %s'
223
 
                        % (self.properties["Name"], command,
 
174
            self.logger(u'Checker for client %s (command "%s")'
 
175
                        u' was killed by signal %s'
 
176
                        % (self.properties[u"name"], command,
224
177
                           os.WTERMSIG(condition)))
225
178
        elif os.WCOREDUMP(condition):
226
 
            self.logger('Checker for client %s (command "%s")'
227
 
                        ' dumped core'
228
 
                        % (self.properties["Name"], command))
 
179
            self.logger(u'Checker for client %s (command "%s")'
 
180
                        u' dumped core'
 
181
                        % (self.properties[u"name"], command))
229
182
        else:
230
 
            self.logger('Checker for client %s completed'
231
 
                        ' mysteriously')
 
183
            self.logger(u'Checker for client %s completed mysteriously')
232
184
        self.update()
233
185
    
234
186
    def checker_started(self, command):
235
 
        #self.logger('Client %s started checker "%s"'
236
 
        #            % (self.properties["Name"], unicode(command)))
 
187
        #self.logger(u'Client %s started checker "%s"'
 
188
        #            % (self.properties[u"name"], unicode(command)))
237
189
        pass
238
190
    
239
191
    def got_secret(self):
240
192
        self.last_checker_failed = False
241
 
        self.logger('Client %s received its secret'
242
 
                    % self.properties["Name"])
 
193
        self.logger(u'Client %s received its secret'
 
194
                    % self.properties[u"name"])
243
195
    
244
196
    def need_approval(self, timeout, default):
245
197
        if not default:
246
 
            message = 'Client %s needs approval within %s seconds'
 
198
            message = u'Client %s needs approval within %s seconds'
247
199
        else:
248
 
            message = 'Client %s will get its secret in %s seconds'
 
200
            message = u'Client %s will get its secret in %s seconds'
249
201
        self.logger(message
250
 
                    % (self.properties["Name"], timeout/1000))
251
 
        self.using_timer(True)
 
202
                    % (self.properties[u"name"], timeout/1000))
252
203
    
253
204
    def rejected(self, reason):
254
 
        self.logger('Client %s was rejected; reason: %s'
255
 
                    % (self.properties["Name"], reason))
 
205
        self.logger(u'Client %s was rejected; reason: %s'
 
206
                    % (self.properties[u"name"], reason))
256
207
    
257
208
    def selectable(self):
258
209
        """Make this a "selectable" widget.
259
210
        This overrides the method from urwid.FlowWidget."""
260
211
        return True
261
212
    
262
 
    def rows(self, maxcolrow, focus=False):
 
213
    def rows(self, (maxcol,), focus=False):
263
214
        """How many rows this widget will occupy might depend on
264
215
        whether we have focus or not.
265
216
        This overrides the method from urwid.FlowWidget"""
266
 
        return self.current_widget(focus).rows(maxcolrow, focus=focus)
 
217
        return self.current_widget(focus).rows((maxcol,), focus=focus)
267
218
    
268
219
    def current_widget(self, focus=False):
269
220
        if focus or self.opened:
273
224
    def update(self):
274
225
        "Called when what is visible on the screen should be updated."
275
226
        # 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",
 
227
        with_standout = { u"normal": u"standout",
 
228
                          u"bold": u"bold-standout",
 
229
                          u"underline-blink":
 
230
                              u"underline-blink-standout",
 
231
                          u"bold-underline-blink":
 
232
                              u"bold-underline-blink-standout",
282
233
                          }
283
234
 
284
235
        # Rebuild focus and non-focus widgets using current properties
285
236
 
286
237
        # 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]
 
238
        base = (u'%(name)s: '
 
239
                      % {u"name": self.properties[u"name"]})
 
240
        if not self.properties[u"enabled"]:
 
241
            message = u"DISABLED"
 
242
        elif self.properties[u"approved_pending"]:
 
243
            if self.properties[u"approved_by_default"]:
 
244
                message = u"Connection established to client. (d)eny?"
 
245
            else:
 
246
                message = u"Seeks approval to send secret. (a)pprove?"
307
247
        elif self.last_checker_failed:
308
248
            timeout = datetime.timedelta(milliseconds
309
 
                                         = self.properties
310
 
                                         ["Timeout"])
 
249
                                         = self.properties[u"timeout"])
311
250
            last_ok = isoformat_to_datetime(
312
 
                max((self.properties["LastCheckedOK"]
313
 
                     or self.properties["Created"]),
314
 
                    self.properties["LastEnabled"]))
 
251
                max((self.properties["last_checked_ok"]
 
252
                     or self.properties["created"]),
 
253
                    self.properties[u"last_enabled"]))
315
254
            timer = timeout - (datetime.datetime.utcnow() - last_ok)
316
 
            message = ('A checker has failed! Time until client'
317
 
                       ' gets disabled: %s'
 
255
            message = (u'A checker has failed! Time until client gets diabled: %s'
318
256
                           % unicode(timer).rsplit(".", 1)[0])
319
257
        else:
320
 
            message = "enabled"
 
258
            message = u"enabled"
321
259
        self._text = "%s%s" % (base, message)
322
260
            
323
261
        if not urwid.supports_unicode():
324
262
            self._text = self._text.encode("ascii", "replace")
325
 
        textlist = [("normal", self._text)]
 
263
        textlist = [(u"normal", self._text)]
326
264
        self._text_widget.set_text(textlist)
327
265
        self._focus_text_widget.set_text([(with_standout[text[0]],
328
266
                                           text[1])
348
286
        if self.delete_hook is not None:
349
287
            self.delete_hook(self)
350
288
    
351
 
    def render(self, maxcolrow, focus=False):
 
289
    def render(self, (maxcol,), focus=False):
352
290
        """Render differently if we have focus.
353
291
        This overrides the method from urwid.FlowWidget"""
354
 
        return self.current_widget(focus).render(maxcolrow,
 
292
        return self.current_widget(focus).render((maxcol,),
355
293
                                                 focus=focus)
356
294
    
357
 
    def keypress(self, maxcolrow, key):
 
295
    def keypress(self, (maxcol,), key):
358
296
        """Handle keys.
359
297
        This overrides the method from urwid.FlowWidget"""
360
 
        if key == "+":
 
298
        if key == u"+":
361
299
            self.proxy.Enable(dbus_interface = client_interface)
362
 
        elif key == "-":
 
300
        elif key == u"-":
363
301
            self.proxy.Disable(dbus_interface = client_interface)
364
 
        elif key == "a":
 
302
        elif key == u"a":
365
303
            self.proxy.Approve(dbus.Boolean(True, variant_level=1),
366
304
                               dbus_interface = client_interface)
367
 
        elif key == "d":
 
305
        elif key == u"d":
368
306
            self.proxy.Approve(dbus.Boolean(False, variant_level=1),
369
307
                                  dbus_interface = client_interface)
370
 
        elif key == "R" or key == "_" or key == "ctrl k":
 
308
        elif key == u"r" or key == u"_" or key == u"ctrl k":
371
309
            self.server_proxy_object.RemoveClient(self.proxy
372
310
                                                  .object_path)
373
 
        elif key == "s":
 
311
        elif key == u"s":
374
312
            self.proxy.StartChecker(dbus_interface = client_interface)
375
 
        elif key == "S":
 
313
        elif key == u"S":
376
314
            self.proxy.StopChecker(dbus_interface = client_interface)
377
 
        elif key == "C":
 
315
        elif key == u"C":
378
316
            self.proxy.CheckedOK(dbus_interface = client_interface)
379
317
        # xxx
380
 
#         elif key == "p" or key == "=":
 
318
#         elif key == u"p" or key == "=":
381
319
#             self.proxy.pause()
382
 
#         elif key == "u" or key == ":":
 
320
#         elif key == u"u" or key == ":":
383
321
#             self.proxy.unpause()
384
 
#         elif key == "RET":
 
322
#         elif key == u"RET":
385
323
#             self.open()
 
324
#        elif key == u"+":
 
325
#            self.proxy.Approve(True)
 
326
#        elif key == u"-":
 
327
#            self.proxy.Approve(False)
386
328
        else:
387
329
            return key
388
330
    
403
345
    "down" key presses, thus not allowing any containing widgets to
404
346
    use them as an excuse to shift focus away from this widget.
405
347
    """
406
 
    def keypress(self, maxcolrow, key):
407
 
        ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)
408
 
        if ret in ("up", "down"):
 
348
    def keypress(self, (maxcol, maxrow), key):
 
349
        ret = super(ConstrainedListBox, self).keypress((maxcol, maxrow), key)
 
350
        if ret in (u"up", u"down"):
409
351
            return
410
352
        return ret
411
353
 
420
362
        self.screen = urwid.curses_display.Screen()
421
363
        
422
364
        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")),
 
365
                (u"normal",
 
366
                 u"default", u"default", None),
 
367
                (u"bold",
 
368
                 u"default", u"default", u"bold"),
 
369
                (u"underline-blink",
 
370
                 u"default", u"default", u"underline"),
 
371
                (u"standout",
 
372
                 u"default", u"default", u"standout"),
 
373
                (u"bold-underline-blink",
 
374
                 u"default", u"default", (u"bold", u"underline")),
 
375
                (u"bold-standout",
 
376
                 u"default", u"default", (u"bold", u"standout")),
 
377
                (u"underline-blink-standout",
 
378
                 u"default", u"default", (u"underline", u"standout")),
 
379
                (u"bold-underline-blink-standout",
 
380
                 u"default", u"default", (u"bold", u"underline",
 
381
                                          u"standout")),
440
382
                ))
441
383
        
442
384
        if urwid.supports_unicode():
443
 
            self.divider = "─" # \u2500
444
 
            #self.divider = "━" # \u2501
 
385
            self.divider = u"─" # \u2500
 
386
            #self.divider = u"━" # \u2501
445
387
        else:
446
 
            #self.divider = "-" # \u002d
447
 
            self.divider = "_" # \u005f
 
388
            #self.divider = u"-" # \u002d
 
389
            self.divider = u"_" # \u005f
448
390
        
449
391
        self.screen.start()
450
392
        
464
406
        # This keeps track of whether self.uilist currently has
465
407
        # self.logbox in it or not
466
408
        self.log_visible = True
467
 
        self.log_wrap = "any"
 
409
        self.log_wrap = u"any"
468
410
        
469
411
        self.rebuild()
470
 
        self.log_message_raw(("bold",
471
 
                              "Mandos Monitor version " + version))
472
 
        self.log_message_raw(("bold",
473
 
                              "q: Quit  ?: Help"))
 
412
        self.log_message_raw((u"bold",
 
413
                              u"Mandos Monitor version " + version))
 
414
        self.log_message_raw((u"bold",
 
415
                              u"q: Quit  ?: Help"))
474
416
        
475
417
        self.busname = domain + '.Mandos'
476
418
        self.main_loop = gobject.MainLoop()
477
419
        self.bus = dbus.SystemBus()
478
420
        mandos_dbus_objc = self.bus.get_object(
479
 
            self.busname, "/", follow_name_owner_changes=True)
 
421
            self.busname, u"/", follow_name_owner_changes=True)
480
422
        self.mandos_serv = dbus.Interface(mandos_dbus_objc,
481
423
                                          dbus_interface
482
424
                                          = server_interface)
487
429
            mandos_clients = dbus.Dictionary()
488
430
        
489
431
        (self.mandos_serv
490
 
         .connect_to_signal("ClientRemoved",
 
432
         .connect_to_signal(u"ClientRemoved",
491
433
                            self.find_and_remove_client,
492
434
                            dbus_interface=server_interface,
493
435
                            byte_arrays=True))
494
436
        (self.mandos_serv
495
 
         .connect_to_signal("ClientAdded",
 
437
         .connect_to_signal(u"ClientAdded",
496
438
                            self.add_new_client,
497
439
                            dbus_interface=server_interface,
498
440
                            byte_arrays=True))
499
441
        (self.mandos_serv
500
 
         .connect_to_signal("ClientNotFound",
 
442
         .connect_to_signal(u"ClientNotFound",
501
443
                            self.client_not_found,
502
444
                            dbus_interface=server_interface,
503
445
                            byte_arrays=True))
518
460
                            path=path)
519
461
    
520
462
    def client_not_found(self, fingerprint, address):
521
 
        self.log_message(("Client with address %s and fingerprint %s"
522
 
                          " could not be found" % (address,
 
463
        self.log_message((u"Client with address %s and fingerprint %s"
 
464
                          u" could not be found" % (address,
523
465
                                                    fingerprint)))
524
466
    
525
467
    def rebuild(self):
527
469
        Call this when the widget layout needs to change"""
528
470
        self.uilist = []
529
471
        #self.uilist.append(urwid.ListBox(self.clients))
530
 
        self.uilist.append(urwid.Frame(ConstrainedListBox(self.
531
 
                                                          clients),
 
472
        self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),
532
473
                                       #header=urwid.Divider(),
533
474
                                       header=None,
534
 
                                       footer=
535
 
                                       urwid.Divider(div_char=
536
 
                                                     self.divider)))
 
475
                                       footer=urwid.Divider(div_char=self.divider)))
537
476
        if self.log_visible:
538
477
            self.uilist.append(self.logbox)
539
478
            pass
541
480
    
542
481
    def log_message(self, message):
543
482
        timestamp = datetime.datetime.now().isoformat()
544
 
        self.log_message_raw(timestamp + ": " + message)
 
483
        self.log_message_raw(timestamp + u": " + message)
545
484
    
546
485
    def log_message_raw(self, markup):
547
486
        """Add a log message to the log buffer."""
550
489
            and len(self.log) > self.max_log_length):
551
490
            del self.log[0:len(self.log)-self.max_log_length-1]
552
491
        self.logbox.set_focus(len(self.logbox.body.contents),
553
 
                              coming_from="above")
 
492
                              coming_from=u"above")
554
493
        self.refresh()
555
494
    
556
495
    def toggle_log_display(self):
557
496
        """Toggle visibility of the log buffer."""
558
497
        self.log_visible = not self.log_visible
559
498
        self.rebuild()
560
 
        #self.log_message("Log visibility changed to: "
561
 
        #                 + unicode(self.log_visible))
 
499
        self.log_message(u"Log visibility changed to: "
 
500
                         + unicode(self.log_visible))
562
501
    
563
502
    def change_log_display(self):
564
503
        """Change type of log display.
565
504
        Currently, this toggles wrapping of text lines."""
566
 
        if self.log_wrap == "clip":
567
 
            self.log_wrap = "any"
 
505
        if self.log_wrap == u"clip":
 
506
            self.log_wrap = u"any"
568
507
        else:
569
 
            self.log_wrap = "clip"
 
508
            self.log_wrap = u"clip"
570
509
        for textwidget in self.log:
571
510
            textwidget.set_wrap_mode(self.log_wrap)
572
 
        #self.log_message("Wrap mode: " + self.log_wrap)
 
511
        self.log_message(u"Wrap mode: " + self.log_wrap)
573
512
    
574
513
    def find_and_remove_client(self, path, name):
575
514
        """Find an client from its object path and remove it.
602
541
        if path is None:
603
542
            path = client.proxy.object_path
604
543
        self.clients_dict[path] = client
605
 
        self.clients.sort(None, lambda c: c.properties["Name"])
 
544
        self.clients.sort(None, lambda c: c.properties[u"name"])
606
545
        self.refresh()
607
546
    
608
547
    def remove_client(self, client, path=None):
639
578
    
640
579
    def process_input(self, source, condition):
641
580
        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
 
581
        translations = { u"ctrl n": u"down",      # Emacs
 
582
                         u"ctrl p": u"up",        # Emacs
 
583
                         u"ctrl v": u"page down", # Emacs
 
584
                         u"meta v": u"page up",   # Emacs
 
585
                         u" ": u"page down",      # less
 
586
                         u"f": u"page down",      # less
 
587
                         u"b": u"page up",        # less
 
588
                         u"j": u"down",           # vi
 
589
                         u"k": u"up",             # vi
651
590
                         }
652
591
        for key in keys:
653
592
            try:
655
594
            except KeyError:    # :-)
656
595
                pass
657
596
            
658
 
            if key == "q" or key == "Q":
 
597
            if key == u"q" or key == u"Q":
659
598
                self.stop()
660
599
                break
661
 
            elif key == "window resize":
 
600
            elif key == u"window resize":
662
601
                self.size = self.screen.get_cols_rows()
663
602
                self.refresh()
664
 
            elif key == "\f":  # Ctrl-L
 
603
            elif key == u"\f":  # Ctrl-L
665
604
                self.refresh()
666
 
            elif key == "l" or key == "D":
 
605
            elif key == u"l" or key == u"D":
667
606
                self.toggle_log_display()
668
607
                self.refresh()
669
 
            elif key == "w" or key == "i":
 
608
            elif key == u"w" or key == u"i":
670
609
                self.change_log_display()
671
610
                self.refresh()
672
 
            elif key == "?" or key == "f1" or key == "esc":
 
611
            elif key == u"?" or key == u"f1" or key == u"esc":
673
612
                if not self.log_visible:
674
613
                    self.log_visible = True
675
614
                    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"))))
 
615
                self.log_message_raw((u"bold",
 
616
                                      u"  ".
 
617
                                      join((u"q: Quit",
 
618
                                            u"?: Help",
 
619
                                            u"l: Log window toggle",
 
620
                                            u"TAB: Switch window",
 
621
                                            u"w: Wrap (log)"))))
 
622
                self.log_message_raw((u"bold",
 
623
                                      u"  "
 
624
                                      .join((u"Clients:",
 
625
                                             u"+: Enable",
 
626
                                             u"-: Disable",
 
627
                                             u"r: Remove",
 
628
                                             u"s: Start new checker",
 
629
                                             u"S: Stop checker",
 
630
                                             u"C: Checker OK",
 
631
                                             u"a: Approve",
 
632
                                             u"d: Deny"))))
694
633
                self.refresh()
695
 
            elif key == "tab":
 
634
            elif key == u"tab":
696
635
                if self.topwidget.get_focus() is self.logbox:
697
636
                    self.topwidget.set_focus(0)
698
637
                else:
699
638
                    self.topwidget.set_focus(self.logbox)
700
639
                self.refresh()
701
 
            #elif (key == "end" or key == "meta >" or key == "G"
702
 
            #      or key == ">"):
 
640
            #elif (key == u"end" or key == u"meta >" or key == u"G"
 
641
            #      or key == u">"):
703
642
            #    pass            # xxx end-of-buffer
704
 
            #elif (key == "home" or key == "meta <" or key == "g"
705
 
            #      or key == "<"):
 
643
            #elif (key == u"home" or key == u"meta <" or key == u"g"
 
644
            #      or key == u"<"):
706
645
            #    pass            # xxx beginning-of-buffer
707
 
            #elif key == "ctrl e" or key == "$":
 
646
            #elif key == u"ctrl e" or key == u"$":
708
647
            #    pass            # xxx move-end-of-line
709
 
            #elif key == "ctrl a" or key == "^":
 
648
            #elif key == u"ctrl a" or key == u"^":
710
649
            #    pass            # xxx move-beginning-of-line
711
 
            #elif key == "ctrl b" or key == "meta (" or key == "h":
 
650
            #elif key == u"ctrl b" or key == u"meta (" or key == u"h":
712
651
            #    pass            # xxx left
713
 
            #elif key == "ctrl f" or key == "meta )" or key == "l":
 
652
            #elif key == u"ctrl f" or key == u"meta )" or key == u"l":
714
653
            #    pass            # xxx right
715
 
            #elif key == "a":
 
654
            #elif key == u"a":
716
655
            #    pass            # scroll up log
717
 
            #elif key == "z":
 
656
            #elif key == u"z":
718
657
            #    pass            # scroll down log
719
658
            elif self.topwidget.selectable():
720
659
                self.topwidget.keypress(self.size, key)