/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-05 10:52:11 UTC
  • Revision ID: teddy@recompile.se-20120505105211-58z3hyjfzep3z2q9
* mandos: White space and other misc. format fixes only.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-monitor
3
3
# 
4
4
# Mandos Monitor - Control and monitor the Mandos server
5
5
# 
6
 
# Copyright © 2009,2010 Teddy Hogeborn
7
 
# Copyright © 2009,2010 Björn Påhlsson
 
6
# Copyright © 2009-2012 Teddy Hogeborn
 
7
# Copyright © 2009-2012 Björn Påhlsson
8
8
# 
9
9
# This program is free software: you can redistribute it and/or modify
10
10
# it under the terms of the GNU General Public License as published by
17
17
#     GNU General Public License for more details.
18
18
# 
19
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/>.
 
20
# along with this program.  If not, see
 
21
# <http://www.gnu.org/licenses/>.
21
22
# 
22
 
# Contact the authors at <mandos@fukt.bsnet.se>.
 
23
# Contact the authors at <mandos@recompile.se>.
23
24
# 
24
25
 
25
 
from __future__ import division, absolute_import, print_function, unicode_literals
 
26
from __future__ import (division, absolute_import, print_function,
 
27
                        unicode_literals)
26
28
 
27
29
import sys
28
30
import os
48
50
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
49
51
 
50
52
# Some useful constants
51
 
domain = 'se.bsnet.fukt'
 
53
domain = 'se.recompile'
52
54
server_interface = domain + '.Mandos'
53
55
client_interface = domain + '.Mandos.Client'
54
 
version = "1.2.3"
 
56
version = "1.5.3"
55
57
 
56
58
# Always run in monochrome mode
57
59
urwid.curses_display.curses.has_colors = lambda : False
86
88
        self.proxy = proxy_object # Mandos Client proxy object
87
89
        
88
90
        self.properties = dict()
89
 
        self.proxy.connect_to_signal("PropertyChanged",
90
 
                                     self.property_changed,
91
 
                                     client_interface,
92
 
                                     byte_arrays=True)
 
91
        self.property_changed_match = (
 
92
            self.proxy.connect_to_signal("PropertyChanged",
 
93
                                         self.property_changed,
 
94
                                         client_interface,
 
95
                                         byte_arrays=True))
93
96
        
94
97
        self.properties.update(
95
98
            self.proxy.GetAll(client_interface,
96
99
                              dbus_interface = dbus.PROPERTIES_IFACE))
97
100
 
98
 
        #XXX This break good super behaviour!
 
101
        #XXX This breaks good super behaviour
99
102
#        super(MandosClientPropertyCache, self).__init__(
100
103
#            *args, **kwargs)
101
104
    
105
108
        """
106
109
        # Update properties dict with new value
107
110
        self.properties[property] = value
 
111
    
 
112
    def delete(self, *args, **kwargs):
 
113
        self.property_changed_match.remove()
 
114
        super(MandosClientPropertyCache, self).__init__(
 
115
            *args, **kwargs)
108
116
 
109
117
 
110
118
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
124
132
        
125
133
        self._update_timer_callback_tag = None
126
134
        self._update_timer_callback_lock = 0
127
 
        self.last_checker_failed = False
128
135
        
129
136
        # The widget shown normally
130
137
        self._text_widget = urwid.Text("")
138
145
        
139
146
        last_checked_ok = isoformat_to_datetime(self.properties
140
147
                                                ["LastCheckedOK"])
141
 
        if last_checked_ok is None:
142
 
            self.last_checker_failed = True
143
 
        else:
144
 
            self.last_checker_failed = ((datetime.datetime.utcnow()
145
 
                                         - last_checked_ok)
146
 
                                        > datetime.timedelta
147
 
                                        (milliseconds=
148
 
                                         self.properties
149
 
                                         ["Interval"]))
150
148
        
151
 
        if self.last_checker_failed:
 
149
        if self.properties ["LastCheckerStatus"] != 0:
152
150
            self.using_timer(True)
153
151
        
154
152
        if self.need_approval:
155
153
            self.using_timer(True)
156
154
        
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)
 
155
        self.match_objects = (
 
156
            self.proxy.connect_to_signal("CheckerCompleted",
 
157
                                         self.checker_completed,
 
158
                                         client_interface,
 
159
                                         byte_arrays=True),
 
160
            self.proxy.connect_to_signal("CheckerStarted",
 
161
                                         self.checker_started,
 
162
                                         client_interface,
 
163
                                         byte_arrays=True),
 
164
            self.proxy.connect_to_signal("GotSecret",
 
165
                                         self.got_secret,
 
166
                                         client_interface,
 
167
                                         byte_arrays=True),
 
168
            self.proxy.connect_to_signal("NeedApproval",
 
169
                                         self.need_approval,
 
170
                                         client_interface,
 
171
                                         byte_arrays=True),
 
172
            self.proxy.connect_to_signal("Rejected",
 
173
                                         self.rejected,
 
174
                                         client_interface,
 
175
                                         byte_arrays=True))
 
176
        #self.logger('Created client {0}'
 
177
        #            .format(self.properties["Name"]))
177
178
    
178
179
    def property_changed(self, property=None, value=None):
179
180
        super(self, MandosClientWidget).property_changed(property,
180
181
                                                         value)
181
182
        if property == "ApprovalPending":
182
183
            using_timer(bool(value))
183
 
        
 
184
        if property == "LastCheckerStatus":
 
185
            using_timer(value != 0)
 
186
            #self.logger('Checker for client {0} (command "{1}") was '
 
187
            #            ' successful'.format(self.properties["Name"],
 
188
            #                                 command))
 
189
    
184
190
    def using_timer(self, flag):
185
191
        """Call this method with True or False when timer should be
186
192
        activated or deactivated.
191
197
        else:
192
198
            self._update_timer_callback_lock -= 1
193
199
        if old == 0 and self._update_timer_callback_lock:
 
200
            # Will update the shown timer value every second
194
201
            self._update_timer_callback_tag = (gobject.timeout_add
195
202
                                               (1000,
196
203
                                                self.update_timer))
200
207
    
201
208
    def checker_completed(self, exitstatus, condition, command):
202
209
        if exitstatus == 0:
203
 
            if self.last_checker_failed:
204
 
                self.last_checker_failed = False
205
 
                self.using_timer(False)
206
 
            #self.logger('Checker for client %s (command "%s")'
207
 
            #            ' was successful'
208
 
            #            % (self.properties["Name"], command))
209
210
            self.update()
210
211
            return
211
212
        # Checker failed
212
 
        if not self.last_checker_failed:
213
 
            self.last_checker_failed = True
214
 
            self.using_timer(True)
215
213
        if os.WIFEXITED(condition):
216
 
            self.logger('Checker for client %s (command "%s")'
217
 
                        ' failed with exit code %s'
218
 
                        % (self.properties["Name"], command,
219
 
                           os.WEXITSTATUS(condition)))
 
214
            self.logger('Checker for client {0} (command "{1}")'
 
215
                        ' failed with exit code {2}'
 
216
                        .format(self.properties["Name"], command,
 
217
                                os.WEXITSTATUS(condition)))
220
218
        elif os.WIFSIGNALED(condition):
221
 
            self.logger('Checker for client %s (command "%s")'
222
 
                        ' was killed by signal %s'
223
 
                        % (self.properties["Name"], command,
224
 
                           os.WTERMSIG(condition)))
 
219
            self.logger('Checker for client {0} (command "{1}") was'
 
220
                        ' killed by signal {2}'
 
221
                        .format(self.properties["Name"], command,
 
222
                                os.WTERMSIG(condition)))
225
223
        elif os.WCOREDUMP(condition):
226
 
            self.logger('Checker for client %s (command "%s")'
 
224
            self.logger('Checker for client {0} (command "{1}")'
227
225
                        ' dumped core'
228
 
                        % (self.properties["Name"], command))
 
226
                        .format(self.properties["Name"], command))
229
227
        else:
230
 
            self.logger('Checker for client %s completed'
231
 
                        ' mysteriously')
 
228
            self.logger('Checker for client {0} completed'
 
229
                        ' mysteriously'
 
230
                        .format(self.properties["Name"]))
232
231
        self.update()
233
232
    
234
233
    def checker_started(self, command):
235
 
        #self.logger('Client %s started checker "%s"'
236
 
        #            % (self.properties["Name"], unicode(command)))
 
234
        """Server signals that a checker started. This could be useful
 
235
           to log in the future. """
 
236
        #self.logger('Client {0} started checker "{1}"'
 
237
        #            .format(self.properties["Name"],
 
238
        #                    unicode(command)))
237
239
        pass
238
240
    
239
241
    def got_secret(self):
240
 
        self.last_checker_failed = False
241
 
        self.logger('Client %s received its secret'
242
 
                    % self.properties["Name"])
 
242
        self.logger('Client {0} received its secret'
 
243
                    .format(self.properties["Name"]))
243
244
    
244
245
    def need_approval(self, timeout, default):
245
246
        if not default:
246
 
            message = 'Client %s needs approval within %s seconds'
 
247
            message = 'Client {0} needs approval within {1} seconds'
247
248
        else:
248
 
            message = 'Client %s will get its secret in %s seconds'
249
 
        self.logger(message
250
 
                    % (self.properties["Name"], timeout/1000))
 
249
            message = 'Client {0} will get its secret in {1} seconds'
 
250
        self.logger(message.format(self.properties["Name"],
 
251
                                   timeout/1000))
251
252
        self.using_timer(True)
252
253
    
253
254
    def rejected(self, reason):
254
 
        self.logger('Client %s was rejected; reason: %s'
255
 
                    % (self.properties["Name"], reason))
 
255
        self.logger('Client {0} was rejected; reason: {1}'
 
256
                    .format(self.properties["Name"], reason))
256
257
    
257
258
    def selectable(self):
258
259
        """Make this a "selectable" widget.
284
285
        # Rebuild focus and non-focus widgets using current properties
285
286
 
286
287
        # Base part of a client. Name!
287
 
        base = ('%(name)s: '
288
 
                      % {"name": self.properties["Name"]})
 
288
        base = '{name}: '.format(name=self.properties["Name"])
289
289
        if not self.properties["Enabled"]:
290
290
            message = "DISABLED"
291
291
        elif self.properties["ApprovalPending"]:
300
300
            else:
301
301
                timer = datetime.timedelta()
302
302
            if self.properties["ApprovedByDefault"]:
303
 
                message = "Approval in %s. (d)eny?"
304
 
            else:
305
 
                message = "Denial in %s. (a)pprove?"
306
 
            message = message % unicode(timer).rsplit(".", 1)[0]
307
 
        elif self.last_checker_failed:
308
 
            timeout = datetime.timedelta(milliseconds
309
 
                                         = self.properties
310
 
                                         ["Timeout"])
311
 
            last_ok = isoformat_to_datetime(
312
 
                max((self.properties["LastCheckedOK"]
313
 
                     or self.properties["Created"]),
314
 
                    self.properties["LastEnabled"]))
315
 
            timer = timeout - (datetime.datetime.utcnow() - last_ok)
 
303
                message = "Approval in {0}. (d)eny?"
 
304
            else:
 
305
                message = "Denial in {0}. (a)pprove?"
 
306
            message = message.format(unicode(timer).rsplit(".", 1)[0])
 
307
        elif self.properties["LastCheckerStatus"] != 0:
 
308
            # When checker has failed, show timer until client expires
 
309
            expires = self.properties["Expires"]
 
310
            if expires == "":
 
311
                timer = datetime.timedelta(0)
 
312
            else:
 
313
                expires = (datetime.datetime.strptime
 
314
                           (expires, '%Y-%m-%dT%H:%M:%S.%f'))
 
315
                timer = expires - datetime.datetime.utcnow()
316
316
            message = ('A checker has failed! Time until client'
317
 
                       ' gets disabled: %s'
318
 
                           % unicode(timer).rsplit(".", 1)[0])
 
317
                       ' gets disabled: {0}'
 
318
                       .format(unicode(timer).rsplit(".", 1)[0]))
319
319
        else:
320
320
            message = "enabled"
321
 
        self._text = "%s%s" % (base, message)
 
321
        self._text = "{0}{1}".format(base, message)
322
322
            
323
323
        if not urwid.supports_unicode():
324
324
            self._text = self._text.encode("ascii", "replace")
337
337
            self.update_hook()
338
338
    
339
339
    def update_timer(self):
340
 
        "called by gobject"
 
340
        """called by gobject. Will indefinitely loop until
 
341
        gobject.source_remove() on tag is called"""
341
342
        self.update()
342
343
        return True             # Keep calling this
343
344
    
344
 
    def delete(self):
 
345
    def delete(self, *args, **kwargs):
345
346
        if self._update_timer_callback_tag is not None:
346
347
            gobject.source_remove(self._update_timer_callback_tag)
347
348
            self._update_timer_callback_tag = None
 
349
        for match in self.match_objects:
 
350
            match.remove()
 
351
        self.match_objects = ()
348
352
        if self.delete_hook is not None:
349
353
            self.delete_hook(self)
 
354
        return super(MandosClientWidget, self).delete(*args, **kwargs)
350
355
    
351
356
    def render(self, maxcolrow, focus=False):
352
357
        """Render differently if we have focus.
358
363
        """Handle keys.
359
364
        This overrides the method from urwid.FlowWidget"""
360
365
        if key == "+":
361
 
            self.proxy.Enable(dbus_interface = client_interface)
 
366
            self.proxy.Enable(dbus_interface = client_interface,
 
367
                              ignore_reply=True)
362
368
        elif key == "-":
363
 
            self.proxy.Disable(dbus_interface = client_interface)
 
369
            self.proxy.Disable(dbus_interface = client_interface,
 
370
                               ignore_reply=True)
364
371
        elif key == "a":
365
372
            self.proxy.Approve(dbus.Boolean(True, variant_level=1),
366
 
                               dbus_interface = client_interface)
 
373
                               dbus_interface = client_interface,
 
374
                               ignore_reply=True)
367
375
        elif key == "d":
368
376
            self.proxy.Approve(dbus.Boolean(False, variant_level=1),
369
 
                                  dbus_interface = client_interface)
 
377
                                  dbus_interface = client_interface,
 
378
                               ignore_reply=True)
370
379
        elif key == "R" or key == "_" or key == "ctrl k":
371
380
            self.server_proxy_object.RemoveClient(self.proxy
372
 
                                                  .object_path)
 
381
                                                  .object_path,
 
382
                                                  ignore_reply=True)
373
383
        elif key == "s":
374
 
            self.proxy.StartChecker(dbus_interface = client_interface)
 
384
            self.proxy.StartChecker(dbus_interface = client_interface,
 
385
                                    ignore_reply=True)
375
386
        elif key == "S":
376
 
            self.proxy.StopChecker(dbus_interface = client_interface)
 
387
            self.proxy.StopChecker(dbus_interface = client_interface,
 
388
                                   ignore_reply=True)
377
389
        elif key == "C":
378
 
            self.proxy.CheckedOK(dbus_interface = client_interface)
 
390
            self.proxy.CheckedOK(dbus_interface = client_interface,
 
391
                                 ignore_reply=True)
379
392
        # xxx
380
393
#         elif key == "p" or key == "=":
381
394
#             self.proxy.pause()
474
487
        
475
488
        self.busname = domain + '.Mandos'
476
489
        self.main_loop = gobject.MainLoop()
477
 
        self.bus = dbus.SystemBus()
478
 
        mandos_dbus_objc = self.bus.get_object(
479
 
            self.busname, "/", follow_name_owner_changes=True)
480
 
        self.mandos_serv = dbus.Interface(mandos_dbus_objc,
481
 
                                          dbus_interface
482
 
                                          = server_interface)
483
 
        try:
484
 
            mandos_clients = (self.mandos_serv
485
 
                              .GetAllClientsWithProperties())
486
 
        except dbus.exceptions.DBusException:
487
 
            mandos_clients = dbus.Dictionary()
488
 
        
489
 
        (self.mandos_serv
490
 
         .connect_to_signal("ClientRemoved",
491
 
                            self.find_and_remove_client,
492
 
                            dbus_interface=server_interface,
493
 
                            byte_arrays=True))
494
 
        (self.mandos_serv
495
 
         .connect_to_signal("ClientAdded",
496
 
                            self.add_new_client,
497
 
                            dbus_interface=server_interface,
498
 
                            byte_arrays=True))
499
 
        (self.mandos_serv
500
 
         .connect_to_signal("ClientNotFound",
501
 
                            self.client_not_found,
502
 
                            dbus_interface=server_interface,
503
 
                            byte_arrays=True))
504
 
        for path, client in mandos_clients.iteritems():
505
 
            client_proxy_object = self.bus.get_object(self.busname,
506
 
                                                      path)
507
 
            self.add_client(MandosClientWidget(server_proxy_object
508
 
                                               =self.mandos_serv,
509
 
                                               proxy_object
510
 
                                               =client_proxy_object,
511
 
                                               properties=client,
512
 
                                               update_hook
513
 
                                               =self.refresh,
514
 
                                               delete_hook
515
 
                                               =self.remove_client,
516
 
                                               logger
517
 
                                               =self.log_message),
518
 
                            path=path)
519
490
    
520
491
    def client_not_found(self, fingerprint, address):
521
 
        self.log_message(("Client with address %s and fingerprint %s"
522
 
                          " could not be found" % (address,
523
 
                                                    fingerprint)))
 
492
        self.log_message("Client with address {0} and fingerprint"
 
493
                         " {1} could not be found"
 
494
                         .format(address, fingerprint))
524
495
    
525
496
    def rebuild(self):
526
497
        """This rebuilds the User Interface.
536
507
                                                     self.divider)))
537
508
        if self.log_visible:
538
509
            self.uilist.append(self.logbox)
539
 
            pass
540
510
        self.topwidget = urwid.Pile(self.uilist)
541
511
    
542
512
    def log_message(self, message):
572
542
        #self.log_message("Wrap mode: " + self.log_wrap)
573
543
    
574
544
    def find_and_remove_client(self, path, name):
575
 
        """Find an client from its object path and remove it.
 
545
        """Find a client by its object path and remove it.
576
546
        
577
547
        This is connected to the ClientRemoved signal from the
578
548
        Mandos server object."""
580
550
            client = self.clients_dict[path]
581
551
        except KeyError:
582
552
            # not found?
 
553
            self.log_message("Unknown client {0!r} ({1!r}) removed"
 
554
                             .format(name, path))
583
555
            return
584
 
        self.remove_client(client, path)
 
556
        client.delete()
585
557
    
586
558
    def add_new_client(self, path):
587
559
        client_proxy_object = self.bus.get_object(self.busname, path)
624
596
    
625
597
    def run(self):
626
598
        """Start the main loop and exit when it's done."""
 
599
        self.bus = dbus.SystemBus()
 
600
        mandos_dbus_objc = self.bus.get_object(
 
601
            self.busname, "/", follow_name_owner_changes=True)
 
602
        self.mandos_serv = dbus.Interface(mandos_dbus_objc,
 
603
                                          dbus_interface
 
604
                                          = server_interface)
 
605
        try:
 
606
            mandos_clients = (self.mandos_serv
 
607
                              .GetAllClientsWithProperties())
 
608
        except dbus.exceptions.DBusException:
 
609
            mandos_clients = dbus.Dictionary()
 
610
        
 
611
        (self.mandos_serv
 
612
         .connect_to_signal("ClientRemoved",
 
613
                            self.find_and_remove_client,
 
614
                            dbus_interface=server_interface,
 
615
                            byte_arrays=True))
 
616
        (self.mandos_serv
 
617
         .connect_to_signal("ClientAdded",
 
618
                            self.add_new_client,
 
619
                            dbus_interface=server_interface,
 
620
                            byte_arrays=True))
 
621
        (self.mandos_serv
 
622
         .connect_to_signal("ClientNotFound",
 
623
                            self.client_not_found,
 
624
                            dbus_interface=server_interface,
 
625
                            byte_arrays=True))
 
626
        for path, client in mandos_clients.iteritems():
 
627
            client_proxy_object = self.bus.get_object(self.busname,
 
628
                                                      path)
 
629
            self.add_client(MandosClientWidget(server_proxy_object
 
630
                                               =self.mandos_serv,
 
631
                                               proxy_object
 
632
                                               =client_proxy_object,
 
633
                                               properties=client,
 
634
                                               update_hook
 
635
                                               =self.refresh,
 
636
                                               delete_hook
 
637
                                               =self.remove_client,
 
638
                                               logger
 
639
                                               =self.log_message),
 
640
                            path=path)
 
641
 
627
642
        self.refresh()
628
643
        self._input_callback_tag = (gobject.io_add_watch
629
644
                                    (sys.stdin.fileno(),