/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: 2011-08-17 22:46:35 UTC
  • Revision ID: teddy@fukt.bsnet.se-20110817224635-l83agxniozmovv6m
* Makefile (LDFLAGS): Added "-Xlinker --as-needed".

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-2012 Teddy Hogeborn
7
 
# Copyright © 2009-2012 Björn Påhlsson
 
6
# Copyright © 2009-2011 Teddy Hogeborn
 
7
# Copyright © 2009-2011 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
21
 
# <http://www.gnu.org/licenses/>.
 
20
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
22
21
# 
23
 
# Contact the authors at <mandos@recompile.se>.
 
22
# Contact the authors at <mandos@fukt.bsnet.se>.
24
23
# 
25
24
 
26
25
from __future__ import (division, absolute_import, print_function,
50
49
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
51
50
 
52
51
# Some useful constants
53
 
domain = 'se.recompile'
 
52
domain = 'se.bsnet.fukt'
54
53
server_interface = domain + '.Mandos'
55
54
client_interface = domain + '.Mandos.Client'
56
 
version = "1.5.3"
 
55
version = "1.3.1"
57
56
 
58
57
# Always run in monochrome mode
59
58
urwid.curses_display.curses.has_colors = lambda : False
132
131
        
133
132
        self._update_timer_callback_tag = None
134
133
        self._update_timer_callback_lock = 0
 
134
        self.last_checker_failed = False
135
135
        
136
136
        # The widget shown normally
137
137
        self._text_widget = urwid.Text("")
145
145
        
146
146
        last_checked_ok = isoformat_to_datetime(self.properties
147
147
                                                ["LastCheckedOK"])
 
148
        if last_checked_ok is None:
 
149
            self.last_checker_failed = True
 
150
        else:
 
151
            self.last_checker_failed = ((datetime.datetime.utcnow()
 
152
                                         - last_checked_ok)
 
153
                                        > datetime.timedelta
 
154
                                        (milliseconds=
 
155
                                         self.properties
 
156
                                         ["Interval"]))
148
157
        
149
 
        if self.properties ["LastCheckerStatus"] != 0:
 
158
        if self.last_checker_failed:
150
159
            self.using_timer(True)
151
160
        
152
161
        if self.need_approval:
173
182
                                         self.rejected,
174
183
                                         client_interface,
175
184
                                         byte_arrays=True))
176
 
        #self.logger('Created client {0}'
177
 
        #            .format(self.properties["Name"]))
 
185
        #self.logger('Created client %s' % (self.properties["Name"]))
178
186
    
179
187
    def property_changed(self, property=None, value=None):
180
188
        super(self, MandosClientWidget).property_changed(property,
181
189
                                                         value)
182
190
        if property == "ApprovalPending":
183
191
            using_timer(bool(value))
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
 
    
 
192
        
190
193
    def using_timer(self, flag):
191
194
        """Call this method with True or False when timer should be
192
195
        activated or deactivated.
197
200
        else:
198
201
            self._update_timer_callback_lock -= 1
199
202
        if old == 0 and self._update_timer_callback_lock:
200
 
            # Will update the shown timer value every second
201
203
            self._update_timer_callback_tag = (gobject.timeout_add
202
204
                                               (1000,
203
205
                                                self.update_timer))
207
209
    
208
210
    def checker_completed(self, exitstatus, condition, command):
209
211
        if exitstatus == 0:
 
212
            if self.last_checker_failed:
 
213
                self.last_checker_failed = False
 
214
                self.using_timer(False)
 
215
            #self.logger('Checker for client %s (command "%s")'
 
216
            #            ' was successful'
 
217
            #            % (self.properties["Name"], command))
210
218
            self.update()
211
219
            return
212
220
        # Checker failed
 
221
        if not self.last_checker_failed:
 
222
            self.last_checker_failed = True
 
223
            self.using_timer(True)
213
224
        if os.WIFEXITED(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)))
 
225
            self.logger('Checker for client %s (command "%s")'
 
226
                        ' failed with exit code %s'
 
227
                        % (self.properties["Name"], command,
 
228
                           os.WEXITSTATUS(condition)))
218
229
        elif os.WIFSIGNALED(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)))
 
230
            self.logger('Checker for client %s (command "%s")'
 
231
                        ' was killed by signal %s'
 
232
                        % (self.properties["Name"], command,
 
233
                           os.WTERMSIG(condition)))
223
234
        elif os.WCOREDUMP(condition):
224
 
            self.logger('Checker for client {0} (command "{1}")'
 
235
            self.logger('Checker for client %s (command "%s")'
225
236
                        ' dumped core'
226
 
                        .format(self.properties["Name"], command))
 
237
                        % (self.properties["Name"], command))
227
238
        else:
228
 
            self.logger('Checker for client {0} completed'
229
 
                        ' mysteriously'
230
 
                        .format(self.properties["Name"]))
 
239
            self.logger('Checker for client %s completed'
 
240
                        ' mysteriously')
231
241
        self.update()
232
242
    
233
243
    def checker_started(self, 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)))
 
244
        #self.logger('Client %s started checker "%s"'
 
245
        #            % (self.properties["Name"], unicode(command)))
239
246
        pass
240
247
    
241
248
    def got_secret(self):
242
 
        self.logger('Client {0} received its secret'
243
 
                    .format(self.properties["Name"]))
 
249
        self.last_checker_failed = False
 
250
        self.logger('Client %s received its secret'
 
251
                    % self.properties["Name"])
244
252
    
245
253
    def need_approval(self, timeout, default):
246
254
        if not default:
247
 
            message = 'Client {0} needs approval within {1} seconds'
 
255
            message = 'Client %s needs approval within %s seconds'
248
256
        else:
249
 
            message = 'Client {0} will get its secret in {1} seconds'
250
 
        self.logger(message.format(self.properties["Name"],
251
 
                                   timeout/1000))
 
257
            message = 'Client %s will get its secret in %s seconds'
 
258
        self.logger(message
 
259
                    % (self.properties["Name"], timeout/1000))
252
260
        self.using_timer(True)
253
261
    
254
262
    def rejected(self, reason):
255
 
        self.logger('Client {0} was rejected; reason: {1}'
256
 
                    .format(self.properties["Name"], reason))
 
263
        self.logger('Client %s was rejected; reason: %s'
 
264
                    % (self.properties["Name"], reason))
257
265
    
258
266
    def selectable(self):
259
267
        """Make this a "selectable" widget.
285
293
        # Rebuild focus and non-focus widgets using current properties
286
294
 
287
295
        # Base part of a client. Name!
288
 
        base = '{name}: '.format(name=self.properties["Name"])
 
296
        base = ('%(name)s: '
 
297
                      % {"name": self.properties["Name"]})
289
298
        if not self.properties["Enabled"]:
290
299
            message = "DISABLED"
291
300
        elif self.properties["ApprovalPending"]:
300
309
            else:
301
310
                timer = datetime.timedelta()
302
311
            if self.properties["ApprovedByDefault"]:
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()
 
312
                message = "Approval in %s. (d)eny?"
 
313
            else:
 
314
                message = "Denial in %s. (a)pprove?"
 
315
            message = message % unicode(timer).rsplit(".", 1)[0]
 
316
        elif self.last_checker_failed:
 
317
            timeout = datetime.timedelta(milliseconds
 
318
                                         = self.properties
 
319
                                         ["Timeout"])
 
320
            last_ok = isoformat_to_datetime(
 
321
                max((self.properties["LastCheckedOK"]
 
322
                     or self.properties["Created"]),
 
323
                    self.properties["LastEnabled"]))
 
324
            timer = timeout - (datetime.datetime.utcnow() - last_ok)
316
325
            message = ('A checker has failed! Time until client'
317
 
                       ' gets disabled: {0}'
318
 
                       .format(unicode(timer).rsplit(".", 1)[0]))
 
326
                       ' gets disabled: %s'
 
327
                           % unicode(timer).rsplit(".", 1)[0])
319
328
        else:
320
329
            message = "enabled"
321
 
        self._text = "{0}{1}".format(base, message)
 
330
        self._text = "%s%s" % (base, message)
322
331
            
323
332
        if not urwid.supports_unicode():
324
333
            self._text = self._text.encode("ascii", "replace")
337
346
            self.update_hook()
338
347
    
339
348
    def update_timer(self):
340
 
        """called by gobject. Will indefinitely loop until
341
 
        gobject.source_remove() on tag is called"""
 
349
        "called by gobject"
342
350
        self.update()
343
351
        return True             # Keep calling this
344
352
    
487
495
        
488
496
        self.busname = domain + '.Mandos'
489
497
        self.main_loop = gobject.MainLoop()
 
498
        self.bus = dbus.SystemBus()
 
499
        mandos_dbus_objc = self.bus.get_object(
 
500
            self.busname, "/", follow_name_owner_changes=True)
 
501
        self.mandos_serv = dbus.Interface(mandos_dbus_objc,
 
502
                                          dbus_interface
 
503
                                          = server_interface)
 
504
        try:
 
505
            mandos_clients = (self.mandos_serv
 
506
                              .GetAllClientsWithProperties())
 
507
        except dbus.exceptions.DBusException:
 
508
            mandos_clients = dbus.Dictionary()
 
509
        
 
510
        (self.mandos_serv
 
511
         .connect_to_signal("ClientRemoved",
 
512
                            self.find_and_remove_client,
 
513
                            dbus_interface=server_interface,
 
514
                            byte_arrays=True))
 
515
        (self.mandos_serv
 
516
         .connect_to_signal("ClientAdded",
 
517
                            self.add_new_client,
 
518
                            dbus_interface=server_interface,
 
519
                            byte_arrays=True))
 
520
        (self.mandos_serv
 
521
         .connect_to_signal("ClientNotFound",
 
522
                            self.client_not_found,
 
523
                            dbus_interface=server_interface,
 
524
                            byte_arrays=True))
 
525
        for path, client in mandos_clients.iteritems():
 
526
            client_proxy_object = self.bus.get_object(self.busname,
 
527
                                                      path)
 
528
            self.add_client(MandosClientWidget(server_proxy_object
 
529
                                               =self.mandos_serv,
 
530
                                               proxy_object
 
531
                                               =client_proxy_object,
 
532
                                               properties=client,
 
533
                                               update_hook
 
534
                                               =self.refresh,
 
535
                                               delete_hook
 
536
                                               =self.remove_client,
 
537
                                               logger
 
538
                                               =self.log_message),
 
539
                            path=path)
490
540
    
491
541
    def client_not_found(self, fingerprint, address):
492
 
        self.log_message("Client with address {0} and fingerprint"
493
 
                         " {1} could not be found"
494
 
                         .format(address, fingerprint))
 
542
        self.log_message(("Client with address %s and fingerprint %s"
 
543
                          " could not be found" % (address,
 
544
                                                    fingerprint)))
495
545
    
496
546
    def rebuild(self):
497
547
        """This rebuilds the User Interface.
507
557
                                                     self.divider)))
508
558
        if self.log_visible:
509
559
            self.uilist.append(self.logbox)
 
560
            pass
510
561
        self.topwidget = urwid.Pile(self.uilist)
511
562
    
512
563
    def log_message(self, message):
550
601
            client = self.clients_dict[path]
551
602
        except KeyError:
552
603
            # not found?
553
 
            self.log_message("Unknown client {0!r} ({1!r}) removed"
554
 
                             .format(name, path))
 
604
            self.log_message("Unknown client %r (%r) removed", name,
 
605
                             path)
555
606
            return
556
607
        client.delete()
557
608
    
596
647
    
597
648
    def run(self):
598
649
        """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
 
 
642
650
        self.refresh()
643
651
        self._input_callback_tag = (gobject.io_add_watch
644
652
                                    (sys.stdin.fileno(),