/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: 2014-07-25 23:42:53 UTC
  • mto: This revision was merged to the branch mainline in revision 724.
  • Revision ID: teddy@recompile.se-20140725234253-m11fdsv01fetbk51
Use the .major attribute on sys.version_info instead of using "[0]".

The components of sys.version_info can now be accessed by attributes
instead of by numerical index, so do that.

* mandos-ctl: Get major version by using "sys.version_info.major".
* mandos-monitor: - '' -

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-2014 Teddy Hogeborn
 
7
# Copyright © 2009-2014 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
25
25
 
26
26
from __future__ import (division, absolute_import, print_function,
27
27
                        unicode_literals)
28
 
 
29
 
from future_builtins import *
 
28
try:
 
29
    from future_builtins import *
 
30
except ImportError:
 
31
    pass
30
32
 
31
33
import sys
32
34
import os
33
 
import signal
34
35
 
35
36
import datetime
36
37
 
38
39
import urwid
39
40
 
40
41
from dbus.mainloop.glib import DBusGMainLoop
41
 
import gobject
 
42
try:
 
43
    import gobject
 
44
except ImportError:
 
45
    from gi.repository import GObject as gobject
42
46
 
43
47
import dbus
44
48
 
45
 
import UserList
46
 
 
47
49
import locale
48
50
 
 
51
if sys.version_info.major == 2:
 
52
    str = unicode
 
53
 
49
54
locale.setlocale(locale.LC_ALL, '')
50
55
 
51
56
import logging
55
60
domain = 'se.recompile'
56
61
server_interface = domain + '.Mandos'
57
62
client_interface = domain + '.Mandos.Client'
58
 
version = "1.5.3"
59
 
 
60
 
# Always run in monochrome mode
61
 
urwid.curses_display.curses.has_colors = lambda : False
62
 
 
63
 
# Urwid doesn't support blinking, but we want it.  Since we have no
64
 
# use for underline on its own, we make underline also always blink.
65
 
urwid.curses_display.curses.A_UNDERLINE |= (
66
 
    urwid.curses_display.curses.A_BLINK)
 
63
version = "1.6.7"
67
64
 
68
65
def isoformat_to_datetime(iso):
69
66
    "Parse an ISO 8601 date string to a datetime.datetime()"
164
161
                                         self.rejected,
165
162
                                         client_interface,
166
163
                                         byte_arrays=True))
167
 
        #self.logger('Created client {0}'
168
 
        #            .format(self.properties["Name"]))
 
164
        self.logger('Created client {}'
 
165
                    .format(self.properties["Name"]), level=0)
169
166
    
170
167
    def using_timer(self, flag):
171
168
        """Call this method with True or False when timer should be
182
179
    
183
180
    def checker_completed(self, exitstatus, condition, command):
184
181
        if exitstatus == 0:
 
182
            self.logger('Checker for client {} (command "{}")'
 
183
                        ' succeeded'.format(self.properties["Name"],
 
184
                                            command), level=0)
185
185
            self.update()
186
186
            return
187
187
        # Checker failed
188
188
        if os.WIFEXITED(condition):
189
 
            self.logger('Checker for client {0} (command "{1}")'
190
 
                        ' failed with exit code {2}'
 
189
            self.logger('Checker for client {} (command "{}") failed'
 
190
                        ' with exit code {}'
191
191
                        .format(self.properties["Name"], command,
192
192
                                os.WEXITSTATUS(condition)))
193
193
        elif os.WIFSIGNALED(condition):
194
 
            self.logger('Checker for client {0} (command "{1}") was'
195
 
                        ' killed by signal {2}'
 
194
            self.logger('Checker for client {} (command "{}") was'
 
195
                        ' killed by signal {}'
196
196
                        .format(self.properties["Name"], command,
197
197
                                os.WTERMSIG(condition)))
198
198
        elif os.WCOREDUMP(condition):
199
 
            self.logger('Checker for client {0} (command "{1}")'
200
 
                        ' dumped core'
201
 
                        .format(self.properties["Name"], command))
 
199
            self.logger('Checker for client {} (command "{}") dumped'
 
200
                        ' core'.format(self.properties["Name"],
 
201
                                       command))
202
202
        else:
203
 
            self.logger('Checker for client {0} completed'
 
203
            self.logger('Checker for client {} completed'
204
204
                        ' mysteriously'
205
205
                        .format(self.properties["Name"]))
206
206
        self.update()
207
207
    
208
208
    def checker_started(self, command):
209
 
        """Server signals that a checker started. This could be useful
210
 
           to log in the future. """
211
 
        #self.logger('Client {0} started checker "{1}"'
212
 
        #            .format(self.properties["Name"],
213
 
        #                    unicode(command)))
214
 
        pass
 
209
        """Server signals that a checker started."""
 
210
        self.logger('Client {} started checker "{}"'
 
211
                    .format(self.properties["Name"],
 
212
                            command), level=0)
215
213
    
216
214
    def got_secret(self):
217
 
        self.logger('Client {0} received its secret'
 
215
        self.logger('Client {} received its secret'
218
216
                    .format(self.properties["Name"]))
219
217
    
220
218
    def need_approval(self, timeout, default):
221
219
        if not default:
222
 
            message = 'Client {0} needs approval within {1} seconds'
 
220
            message = 'Client {} needs approval within {} seconds'
223
221
        else:
224
 
            message = 'Client {0} will get its secret in {1} seconds'
 
222
            message = 'Client {} will get its secret in {} seconds'
225
223
        self.logger(message.format(self.properties["Name"],
226
224
                                   timeout/1000))
227
225
    
228
226
    def rejected(self, reason):
229
 
        self.logger('Client {0} was rejected; reason: {1}'
 
227
        self.logger('Client {} was rejected; reason: {}'
230
228
                    .format(self.properties["Name"], reason))
231
229
    
232
230
    def selectable(self):
276
274
            else:
277
275
                timer = datetime.timedelta()
278
276
            if self.properties["ApprovedByDefault"]:
279
 
                message = "Approval in {0}. (d)eny?"
 
277
                message = "Approval in {}. (d)eny?"
280
278
            else:
281
 
                message = "Denial in {0}. (a)pprove?"
282
 
            message = message.format(unicode(timer).rsplit(".", 1)[0])
 
279
                message = "Denial in {}. (a)pprove?"
 
280
            message = message.format(str(timer).rsplit(".", 1)[0])
283
281
            self.using_timer(True)
284
282
        elif self.properties["LastCheckerStatus"] != 0:
285
283
            # When checker has failed, show timer until client expires
292
290
                timer = max(expires - datetime.datetime.utcnow(),
293
291
                            datetime.timedelta())
294
292
            message = ('A checker has failed! Time until client'
295
 
                       ' gets disabled: {0}'
296
 
                       .format(unicode(timer).rsplit(".", 1)[0]))
 
293
                       ' gets disabled: {}'
 
294
                       .format(str(timer).rsplit(".", 1)[0]))
297
295
            self.using_timer(True)
298
296
        else:
299
297
            message = "enabled"
300
298
            self.using_timer(False)
301
 
        self._text = "{0}{1}".format(base, message)
 
299
        self._text = "{}{}".format(base, message)
302
300
        
303
301
        if not urwid.supports_unicode():
304
302
            self._text = self._text.encode("ascii", "replace")
382
380
    def property_changed(self, property=None, **kwargs):
383
381
        """Call self.update() if old value is not new value.
384
382
        This overrides the method from MandosClientPropertyCache"""
385
 
        property_name = unicode(property)
 
383
        property_name = str(property)
386
384
        old_value = self.properties.get(property_name)
387
385
        super(MandosClientWidget, self).property_changed(
388
386
            property=property, **kwargs)
406
404
    """This is the entire user interface - the whole screen
407
405
    with boxes, lists of client widgets, etc.
408
406
    """
409
 
    def __init__(self, max_log_length=1000):
 
407
    def __init__(self, max_log_length=1000, log_level=1):
410
408
        DBusGMainLoop(set_as_default=True)
411
409
        
412
410
        self.screen = urwid.curses_display.Screen()
415
413
                ("normal",
416
414
                 "default", "default", None),
417
415
                ("bold",
418
 
                 "default", "default", "bold"),
 
416
                 "bold", "default", "bold"),
419
417
                ("underline-blink",
420
 
                 "default", "default", "underline"),
 
418
                 "underline,blink", "default", "underline,blink"),
421
419
                ("standout",
422
 
                 "default", "default", "standout"),
 
420
                 "standout", "default", "standout"),
423
421
                ("bold-underline-blink",
424
 
                 "default", "default", ("bold", "underline")),
 
422
                 "bold,underline,blink", "default", "bold,underline,blink"),
425
423
                ("bold-standout",
426
 
                 "default", "default", ("bold", "standout")),
 
424
                 "bold,standout", "default", "bold,standout"),
427
425
                ("underline-blink-standout",
428
 
                 "default", "default", ("underline", "standout")),
 
426
                 "underline,blink,standout", "default",
 
427
                 "underline,blink,standout"),
429
428
                ("bold-underline-blink-standout",
430
 
                 "default", "default", ("bold", "underline",
431
 
                                          "standout")),
 
429
                 "bold,underline,blink,standout", "default",
 
430
                 "bold,underline,blink,standout"),
432
431
                ))
433
432
        
434
433
        if urwid.supports_unicode():
449
448
        self.log = []
450
449
        self.max_log_length = max_log_length
451
450
        
 
451
        self.log_level = log_level
 
452
        
452
453
        # We keep a reference to the log widget so we can remove it
453
454
        # from the ListWalker without it getting destroyed
454
455
        self.logbox = ConstrainedListBox(self.log)
468
469
        self.main_loop = gobject.MainLoop()
469
470
    
470
471
    def client_not_found(self, fingerprint, address):
471
 
        self.log_message("Client with address {0} and fingerprint"
472
 
                         " {1} could not be found"
 
472
        self.log_message("Client with address {} and fingerprint {}"
 
473
                         " could not be found"
473
474
                         .format(address, fingerprint))
474
475
    
475
476
    def rebuild(self):
488
489
            self.uilist.append(self.logbox)
489
490
        self.topwidget = urwid.Pile(self.uilist)
490
491
    
491
 
    def log_message(self, message):
 
492
    def log_message(self, message, level=1):
 
493
        """Log message formatted with timestamp"""
 
494
        if level < self.log_level:
 
495
            return
492
496
        timestamp = datetime.datetime.now().isoformat()
493
 
        self.log_message_raw(timestamp + ": " + message)
 
497
        self.log_message_raw("{}: {}".format(timestamp, message),
 
498
                             level=level)
494
499
    
495
 
    def log_message_raw(self, markup):
 
500
    def log_message_raw(self, markup, level=1):
496
501
        """Add a log message to the log buffer."""
 
502
        if level < self.log_level:
 
503
            return
497
504
        self.log.append(urwid.Text(markup, wrap=self.log_wrap))
498
505
        if (self.max_log_length
499
506
            and len(self.log) > self.max_log_length):
506
513
        """Toggle visibility of the log buffer."""
507
514
        self.log_visible = not self.log_visible
508
515
        self.rebuild()
509
 
        #self.log_message("Log visibility changed to: "
510
 
        #                 + unicode(self.log_visible))
 
516
        self.log_message("Log visibility changed to: {}"
 
517
                         .format(self.log_visible), level=0)
511
518
    
512
519
    def change_log_display(self):
513
520
        """Change type of log display.
518
525
            self.log_wrap = "clip"
519
526
        for textwidget in self.log:
520
527
            textwidget.set_wrap_mode(self.log_wrap)
521
 
        #self.log_message("Wrap mode: " + self.log_wrap)
 
528
        self.log_message("Wrap mode: {}".format(self.log_wrap),
 
529
                         level=0)
522
530
    
523
531
    def find_and_remove_client(self, path, name):
524
532
        """Find a client by its object path and remove it.
529
537
            client = self.clients_dict[path]
530
538
        except KeyError:
531
539
            # not found?
532
 
            self.log_message("Unknown client {0!r} ({1!r}) removed"
 
540
            self.log_message("Unknown client {!r} ({!r}) removed"
533
541
                             .format(name, path))
534
542
            return
535
543
        client.delete()
553
561
        if path is None:
554
562
            path = client.proxy.object_path
555
563
        self.clients_dict[path] = client
556
 
        self.clients.sort(None, lambda c: c.properties["Name"])
 
564
        self.clients.sort(key=lambda c: c.properties["Name"])
557
565
        self.refresh()
558
566
    
559
567
    def remove_client(self, client, path=None):
561
569
        if path is None:
562
570
            path = client.proxy.object_path
563
571
        del self.clients_dict[path]
564
 
        if not self.clients_dict:
565
 
            # Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
566
 
            # is completely emptied, we need to recreate it.
567
 
            self.clients = urwid.SimpleListWalker([])
568
 
            self.rebuild()
569
572
        self.refresh()
570
573
    
571
574
    def refresh(self):
584
587
        try:
585
588
            mandos_clients = (self.mandos_serv
586
589
                              .GetAllClientsWithProperties())
 
590
            if not mandos_clients:
 
591
                self.log_message_raw(("bold", "Note: Server has no clients."))
587
592
        except dbus.exceptions.DBusException:
 
593
            self.log_message_raw(("bold", "Note: No Mandos server running."))
588
594
            mandos_clients = dbus.Dictionary()
589
595
        
590
596
        (self.mandos_serv
602
608
                            self.client_not_found,
603
609
                            dbus_interface=server_interface,
604
610
                            byte_arrays=True))
605
 
        for path, client in mandos_clients.iteritems():
 
611
        for path, client in mandos_clients.items():
606
612
            client_proxy_object = self.bus.get_object(self.busname,
607
613
                                                      path)
608
614
            self.add_client(MandosClientWidget(server_proxy_object
655
661
            elif key == "window resize":
656
662
                self.size = self.screen.get_cols_rows()
657
663
                self.refresh()
658
 
            elif key == "\f":  # Ctrl-L
 
664
            elif key == "ctrl l":
 
665
                self.screen.clear()
659
666
                self.refresh()
660
667
            elif key == "l" or key == "D":
661
668
                self.toggle_log_display()
673
680
                                            "?: Help",
674
681
                                            "l: Log window toggle",
675
682
                                            "TAB: Switch window",
676
 
                                            "w: Wrap (log)"))))
 
683
                                            "w: Wrap (log lines)",
 
684
                                            "v: Toggle verbose log",
 
685
                                            ))))
677
686
                self.log_message_raw(("bold",
678
687
                                      "  "
679
688
                                      .join(("Clients:",
692
701
                else:
693
702
                    self.topwidget.set_focus(self.logbox)
694
703
                self.refresh()
 
704
            elif key == "v":
 
705
                if self.log_level == 0:
 
706
                    self.log_level = 1
 
707
                    self.log_message("Verbose mode: Off")
 
708
                else:
 
709
                    self.log_level = 0
 
710
                    self.log_message("Verbose mode: On")
695
711
            #elif (key == "end" or key == "meta >" or key == "G"
696
712
            #      or key == ">"):
697
713
            #    pass            # xxx end-of-buffer
720
736
    ui.run()
721
737
except KeyboardInterrupt:
722
738
    ui.screen.stop()
723
 
except Exception, e:
724
 
    ui.log_message(unicode(e))
 
739
except Exception as e:
 
740
    ui.log_message(str(e))
725
741
    ui.screen.stop()
726
742
    raise