/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: 2008-08-01 20:03:03 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080801200303-3xjn9gjewg87365i
* plugbasedclient.c (main): Check if plugin dir could be opened.  Set
                            FD_CLOEXEC on the directory, if possible,
                            and also on both ends of the pipe.  Do not
                            allocate buffer for process in advance.
                            Free the plugin list.  Bug fix: exit if no
                            plugins found, not if any found.  Set
                            "exitstatus" in many places.  Simplify and
                            un-indent the loop reading process pipes.
                            Renamed process list iterator to "proc".
                            Bug fix:  retry password write on EINTR.
                            Free the process list properly, including
                            the process structs themselves.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-monitor
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