/mandos/release

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/release
237.2.167 by Teddy Hogeborn
* mandos-monitor: New prototype version of interactive server
1
#!/usr/bin/python
2
# -*- mode: python; coding: utf-8 -*-
3
4
from __future__ import division, absolute_import, with_statement
5
6
import sys
7
import signal
8
9
import urwid.curses_display
10
import urwid
11
12
from dbus.mainloop.glib import DBusGMainLoop
13
import gobject
14
15
import dbus
16
17
import UserList
18
19
# Some useful constants
20
domain = 'se.bsnet.fukt'
21
server_interface = domain + '.Mandos'
22
client_interface = domain + '.Mandos.Client'
23
version = "1.0.14"
24
25
# Always run in monochrome mode
26
urwid.curses_display.curses.has_colors = lambda : False
27
28
# Urwid doesn't support blinking, but we want it.  Since we have no
29
# use for underline on its own, we make underline also always blink.
30
urwid.curses_display.curses.A_UNDERLINE |= (
31
    urwid.curses_display.curses.A_BLINK)
32
33
class MandosClientPropertyCache(object):
34
    """This wraps a Mandos Client D-Bus proxy object, caches the
35
    properties and calls a hook function when any of them are
36
    changed.
37
    """
38
    def __init__(self, proxy_object=None, properties=None, *args,
39
                 **kwargs):
40
        # Type conversion mapping
41
        self.type_map = {
42
            dbus.ObjectPath: unicode,
43
            dbus.ByteArray: str,
44
            dbus.Signature: unicode,
45
            dbus.Byte: chr,
46
            dbus.Int16: int,
47
            dbus.UInt16: int,
48
            dbus.Int32: int,
49
            dbus.UInt32: int,
50
            dbus.Int64: int,
51
            dbus.UInt64: int,
52
            dbus.Dictionary: dict,
53
            dbus.Array: list,
54
            dbus.String: unicode,
55
            dbus.Boolean: bool,
56
            dbus.Double: float,
57
            dbus.Struct: tuple,
58
            }
59
        self.proxy = proxy_object # Mandos Client proxy object
60
        
61
        if properties is None:
62
            self.properties = dict()
63
        else:
64
            self.properties = dict(self.convert_property(prop, val)
65
                                   for prop, val in
66
                                   properties.iteritems())
67
        self.proxy.connect_to_signal("PropertyChanged",
68
                                     self.property_changed,
69
                                     client_interface,
70
                                     byte_arrays=True)
71
        
72
        if properties is None:
73
            self.properties.update(
74
                self.convert_property(prop, val)
75
                for prop, val in
76
                self.proxy.GetAll(client_interface,
77
                                  dbus_interface =
78
                                  dbus.PROPERTIES_IFACE).iteritems())
79
        super(MandosClientPropertyCache, self).__init__(
80
            proxy_object=proxy_object,
81
            properties=properties, *args, **kwargs)
82
    
83
    def convert_property(self, property, value):
84
        """This converts the arguments from a D-Bus signal, which are
85
        D-Bus types, into normal Python types, using a conversion
86
        function from "self.type_map".
87
        """
88
        property_name = unicode(property) # Always a dbus.String
89
        if isinstance(value, dbus.UTF8String):
90
            # Should not happen, but prepare for it anyway
91
            value = dbus.String(str(value).decode("utf-8"))
92
        try:
93
            convfunc = self.type_map[type(value)]
94
        except KeyError:
95
            # Unknown type, return unmodified
96
            return property_name, value
97
        return property_name, convfunc(value)
98
    def property_changed(self, property=None, value=None):
99
        """This is called whenever we get a PropertyChanged signal
100
        It updates the changed property in the "properties" dict.
101
        """
102
        # Convert name and value
103
        property_name, cvalue = self.convert_property(property, value)
104
        # Update properties dict with new value
105
        self.properties[property_name] = cvalue
106
107
108
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
109
    """A Mandos Client which is visible on the screen.
110
    """
111
    
112
    def __init__(self, server_proxy_object=None, update_hook=None,
113
                 delete_hook=None, *args, **kwargs):
114
        # Called on update
115
        self.update_hook = update_hook
116
        # Called on delete
117
        self.delete_hook = delete_hook
118
        # Mandos Server proxy object
119
        self.server_proxy_object = server_proxy_object
120
        
121
        # The widget shown normally
122
        self._text_widget = urwid.Text("")
123
        # The widget shown when we have focus
124
        self._focus_text_widget = urwid.Text("")
125
        super(MandosClientWidget, self).__init__(
126
            update_hook=update_hook, delete_hook=delete_hook,
127
            *args, **kwargs)
128
        self.update()
129
        self.opened = False
130
    
131
    def selectable(self):
132
        """Make this a "selectable" widget.
133
        This overrides the method from urwid.FlowWidget."""
134
        return True
135
    
136
    def rows(self, (maxcol,), focus=False):
137
        """How many rows this widget will occupy might depend on
138
        whether we have focus or not.
139
        This overrides the method from urwid.FlowWidget"""
140
        return self.current_widget(focus).rows((maxcol,), focus=focus)
141
    
142
    def current_widget(self, focus=False):
143
        if focus or self.opened:
144
            return self._focus_widget
145
        return self._widget
146
    
147
    def update(self):
148
        "Called when what is visible on the screen should be updated."
149
        # How to add standout mode to a style
150
        with_standout = { u"normal": u"standout",
151
                          u"bold": u"bold-standout",
152
                          u"underline-blink":
153
                              u"underline-blink-standout",
154
                          u"bold-underline-blink":
155
                              u"bold-underline-blink-standout",
156
                          }
157
        
158
        # Rebuild focus and non-focus widgets using current properties
159
        self._text = (u'name="%(name)s", enabled=%(enabled)s'
160
                      % self.properties)
161
        if not urwid.supports_unicode():
162
            self._text = self._text.encode("ascii", "replace")
163
        textlist = [(u"normal", u"BLĂ„RGH: "), (u"bold", self._text)]
164
        self._text_widget.set_text(textlist)
165
        self._focus_text_widget.set_text([(with_standout[text[0]],
166
                                           text[1])
167
                                          if isinstance(text, tuple)
168
                                          else text
169
                                          for text in textlist])
170
        self._widget = self._text_widget
171
        self._focus_widget = urwid.AttrWrap(self._focus_text_widget,
172
                                            "standout")
173
        # Run update hook, if any
174
        if self.update_hook is not None:
175
            self.update_hook()
176
    
177
    def delete(self):
178
        if self.delete_hook is not None:
179
            self.delete_hook(self)
180
    
181
    def render(self, (maxcol,), focus=False):
182
        """Render differently if we have focus.
183
        This overrides the method from urwid.FlowWidget"""
184
        return self.current_widget(focus).render((maxcol,),
185
                                                 focus=focus)
186
    
187
    def keypress(self, (maxcol,), key):
188
        """Handle keys.
189
        This overrides the method from urwid.FlowWidget"""
190
        if key == u"e" or key == u"+":
191
            self.proxy.Enable()
192
        elif key == u"d" or key == u"-":
193
            self.proxy.Disable()
194
        elif key == u"r" or key == u"_":
195
            self.server_proxy_object.RemoveClient(self.proxy
196
                                                  .object_path)
197
        elif key == u"s":
198
            self.proxy.StartChecker()
199
        elif key == u"c":
200
            self.proxy.StopChecker()
201
        elif key == u"S":
202
            self.proxy.CheckedOK()
203
        # xxx
204
#         elif key == u"p" or key == "=":
205
#             self.proxy.pause()
206
#         elif key == u"u" or key == ":":
207
#             self.proxy.unpause()
208
#         elif key == u"RET":
209
#             self.open()
210
        else:
211
            return key
212
    
213
    def property_changed(self, property=None, value=None,
214
                         *args, **kwargs):
215
        """Call self.update() if old value is not new value.
216
        This overrides the method from MandosClientPropertyCache"""
217
        property_name = unicode(property)
218
        old_value = self.properties.get(property_name)
219
        super(MandosClientWidget, self).property_changed(
220
            property=property, value=value, *args, **kwargs)
221
        if self.properties.get(property_name) != old_value:
222
            self.update()
223
224
225
class UserInterface(object):
226
    """This is the entire user interface - the whole screen
227
    with boxes, lists of client widgets, etc.
228
    """
229
    def __init__(self):
230
        DBusGMainLoop(set_as_default=True )
231
        
232
        self.screen = urwid.curses_display.Screen()
233
        
234
        self.screen.register_palette((
235
                (u"normal",
236
                 u"default", u"default", None),
237
                (u"bold",
238
                 u"default", u"default", u"bold"),
239
                (u"underline-blink",
240
                 u"default", u"default", u"underline"),
241
                (u"standout",
242
                 u"default", u"default", u"standout"),
243
                (u"bold-underline-blink",
244
                 u"default", u"default", (u"bold", u"underline")),
245
                (u"bold-standout",
246
                 u"default", u"default", (u"bold", u"standout")),
247
                (u"underline-blink-standout",
248
                 u"default", u"default", (u"underline", u"standout")),
249
                (u"bold-underline-blink-standout",
250
                 u"default", u"default", (u"bold", u"underline",
251
                                          u"standout")),
252
                ))
253
        
254
        self.screen.start()
255
        
256
        self.size = self.screen.get_cols_rows()
257
        
258
        self.clients = urwid.SimpleListWalker([])
259
        self.clients_dict = {}
260
        self.topwidget = urwid.LineBox(urwid.ListBox(self.clients))
261
        #self.topwidget = urwid.ListBox(clients)
262
        
263
        self.busname = domain + '.Mandos'
264
        self.main_loop = gobject.MainLoop()
265
        self.bus = dbus.SystemBus()
266
        mandos_dbus_objc = self.bus.get_object(
267
            self.busname, u"/", follow_name_owner_changes=True)
268
        self.mandos_serv = dbus.Interface(mandos_dbus_objc,
269
                                          dbus_interface
270
                                          = server_interface)
271
        try:
272
            mandos_clients = (self.mandos_serv
273
                              .GetAllClientsWithProperties())
274
        except dbus.exceptions.DBusException:
275
            mandos_clients = dbus.Dictionary()
276
        
277
        (self.mandos_serv
278
         .connect_to_signal("ClientRemoved",
279
                            self.find_and_remove_client,
280
                            dbus_interface=server_interface,
281
                            byte_arrays=True))
282
        (self.mandos_serv
283
         .connect_to_signal("ClientAdded",
284
                            self.add_new_client,
285
                            dbus_interface=server_interface,
286
                            byte_arrays=True))
287
        for path, client in (mandos_clients.iteritems()):
288
            client_proxy_object = self.bus.get_object(self.busname,
289
                                                      path)
290
            self.add_client(MandosClientWidget(server_proxy_object
291
                                               =self.mandos_serv,
292
                                               proxy_object
293
                                               =client_proxy_object,
294
                                               properties=client,
295
                                               update_hook
296
                                               =self.refresh,
297
                                               delete_hook
298
                                               =self.remove_client),
299
                            path=path)
300
    
301
    def find_and_remove_client(self, path, name):
302
        """Find an client from its object path and remove it.
303
        
304
        This is connected to the ClientRemoved signal from the
305
        Mandos server object."""
306
        try:
307
            client = self.clients_dict[path]
308
        except KeyError:
309
            # not found?
310
            return
311
        self.remove_client(client, path)
312
    
313
    def add_new_client(self, path, properties):
314
        client_proxy_object = self.bus.get_object(self.busname, path)
315
        self.add_client(MandosClientWidget(server_proxy_object
316
                                           =self.mandos_serv,
317
                                           proxy_object
318
                                           =client_proxy_object,
319
                                           properties=properties,
320
                                           update_hook
321
                                           =self.refresh,
322
                                           delete_hook
323
                                           =self.remove_client),
324
                        path=path)
325
    
326
    def add_client(self, client, path=None):
327
        self.clients.append(client)
328
        if path is None:
329
            path = client.proxy.object_path
330
        self.clients_dict[path] = client
331
        self.clients.sort(None, lambda c: c.properties[u"name"])
332
        self.refresh()
333
    
334
    def remove_client(self, client, path=None):
335
        self.clients.remove(client)
336
        if path is None:
337
            path = client.proxy.object_path
338
        del self.clients_dict[path]
339
        self.refresh()
340
    
341
    def refresh(self):
342
        """Redraw the screen"""
343
        canvas = self.topwidget.render(self.size, focus=True)
344
        self.screen.draw_screen(self.size, canvas)
345
    
346
    def run(self):
347
        """Start the main loop and exit when it's done."""
348
        self.refresh()
349
        self._input_callback_tag = (gobject.io_add_watch
350
                                    (sys.stdin.fileno(),
351
                                     gobject.IO_IN,
352
                                     self.process_input))
353
        self.main_loop.run()
354
        # Main loop has finished, we should close everything now
355
        gobject.source_remove(self._input_callback_tag)
356
        self.screen.stop()
357
    
358
    def stop(self):
359
        self.main_loop.quit()
360
    
361
    def process_input(self, source, condition):
362
        keys = self.screen.get_input()
363
        translations = { u"j": u"down",
364
                         u"k": u"up",
365
                         }
366
        for key in keys:
367
            try:
368
                key = translations[key]
369
            except KeyError:    # :-)
370
                pass
371
            
372
            if key == u"q" or key == u"Q":
373
                self.stop()
374
                break
375
            elif key == u"window resize":
376
                self.size = self.screen.get_cols_rows()
377
                self.refresh()
378
            elif key == "":
379
                self.refresh()
380
            elif self.topwidget.selectable():
381
                self.topwidget.keypress(self.size, key)
382
                self.refresh()
383
        return True
384
385
ui = UserInterface()
386
try:
387
    ui.run()
388
except:
389
    ui.screen.stop()
390
    raise