/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: 2012-05-03 19:06:02 UTC
  • Revision ID: teddy@recompile.se-20120503190602-uqghef5rbpqdvybx
* mandos-monitor: Use new string format method.

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