/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-05-12 21:02:38 UTC
  • Revision ID: teddy@recompile.se-20140512210238-t6o8b1ieeojrs0xl
Do not run self-tests when building arch-indep Debian package.

* debian/rules (override_dh_auto_test-arch): New; does nothing.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-monitor
48
48
 
49
49
import locale
50
50
 
51
 
if sys.version_info.major == 2:
 
51
if sys.version_info[0] == 2:
52
52
    str = unicode
53
53
 
54
54
locale.setlocale(locale.LC_ALL, '')
60
60
domain = 'se.recompile'
61
61
server_interface = domain + '.Mandos'
62
62
client_interface = domain + '.Mandos.Client'
63
 
version = "1.6.9"
 
63
version = "1.6.5"
64
64
 
65
65
def isoformat_to_datetime(iso):
66
66
    "Parse an ISO 8601 date string to a datetime.datetime()"
87
87
        self.proxy = proxy_object # Mandos Client proxy object
88
88
        self.properties = dict() if properties is None else properties
89
89
        self.property_changed_match = (
90
 
            self.proxy.connect_to_signal("PropertiesChanged",
91
 
                                         self.properties_changed,
92
 
                                         dbus.PROPERTIES_IFACE,
 
90
            self.proxy.connect_to_signal("PropertyChanged",
 
91
                                         self._property_changed,
 
92
                                         client_interface,
93
93
                                         byte_arrays=True))
94
94
        
95
95
        if properties is None:
100
100
        
101
101
        super(MandosClientPropertyCache, self).__init__(**kwargs)
102
102
    
103
 
    def properties_changed(self, interface, properties, invalidated):
104
 
        """This is called whenever we get a PropertiesChanged signal
105
 
        It updates the changed properties in the "properties" dict.
 
103
    def _property_changed(self, property, value):
 
104
        """Helper which takes positional arguments"""
 
105
        return self.property_changed(property=property, value=value)
 
106
    
 
107
    def property_changed(self, property=None, value=None):
 
108
        """This is called whenever we get a PropertyChanged signal
 
109
        It updates the changed property in the "properties" dict.
106
110
        """
107
111
        # Update properties dict with new value
108
 
        self.properties.update(properties)
 
112
        self.properties[property] = value
109
113
    
110
114
    def delete(self):
111
115
        self.property_changed_match.remove()
157
161
                                         self.rejected,
158
162
                                         client_interface,
159
163
                                         byte_arrays=True))
160
 
        self.logger('Created client {}'
161
 
                    .format(self.properties["Name"]), level=0)
 
164
        #self.logger('Created client {0}'
 
165
        #            .format(self.properties["Name"]))
162
166
    
163
167
    def using_timer(self, flag):
164
168
        """Call this method with True or False when timer should be
175
179
    
176
180
    def checker_completed(self, exitstatus, condition, command):
177
181
        if exitstatus == 0:
178
 
            self.logger('Checker for client {} (command "{}")'
179
 
                        ' succeeded'.format(self.properties["Name"],
180
 
                                            command), level=0)
181
182
            self.update()
182
183
            return
183
184
        # Checker failed
184
185
        if os.WIFEXITED(condition):
185
 
            self.logger('Checker for client {} (command "{}") failed'
186
 
                        ' with exit code {}'
 
186
            self.logger('Checker for client {0} (command "{1}")'
 
187
                        ' failed with exit code {2}'
187
188
                        .format(self.properties["Name"], command,
188
189
                                os.WEXITSTATUS(condition)))
189
190
        elif os.WIFSIGNALED(condition):
190
 
            self.logger('Checker for client {} (command "{}") was'
191
 
                        ' killed by signal {}'
 
191
            self.logger('Checker for client {0} (command "{1}") was'
 
192
                        ' killed by signal {2}'
192
193
                        .format(self.properties["Name"], command,
193
194
                                os.WTERMSIG(condition)))
194
195
        elif os.WCOREDUMP(condition):
195
 
            self.logger('Checker for client {} (command "{}") dumped'
196
 
                        ' core'.format(self.properties["Name"],
197
 
                                       command))
 
196
            self.logger('Checker for client {0} (command "{1}")'
 
197
                        ' dumped core'
 
198
                        .format(self.properties["Name"], command))
198
199
        else:
199
 
            self.logger('Checker for client {} completed'
 
200
            self.logger('Checker for client {0} completed'
200
201
                        ' mysteriously'
201
202
                        .format(self.properties["Name"]))
202
203
        self.update()
203
204
    
204
205
    def checker_started(self, command):
205
 
        """Server signals that a checker started."""
206
 
        self.logger('Client {} started checker "{}"'
207
 
                    .format(self.properties["Name"],
208
 
                            command), level=0)
 
206
        """Server signals that a checker started. This could be useful
 
207
           to log in the future. """
 
208
        #self.logger('Client {0} started checker "{1}"'
 
209
        #            .format(self.properties["Name"],
 
210
        #                    str(command)))
 
211
        pass
209
212
    
210
213
    def got_secret(self):
211
 
        self.logger('Client {} received its secret'
 
214
        self.logger('Client {0} received its secret'
212
215
                    .format(self.properties["Name"]))
213
216
    
214
217
    def need_approval(self, timeout, default):
215
218
        if not default:
216
 
            message = 'Client {} needs approval within {} seconds'
 
219
            message = 'Client {0} needs approval within {1} seconds'
217
220
        else:
218
 
            message = 'Client {} will get its secret in {} seconds'
 
221
            message = 'Client {0} will get its secret in {1} seconds'
219
222
        self.logger(message.format(self.properties["Name"],
220
223
                                   timeout/1000))
221
224
    
222
225
    def rejected(self, reason):
223
 
        self.logger('Client {} was rejected; reason: {}'
 
226
        self.logger('Client {0} was rejected; reason: {1}'
224
227
                    .format(self.properties["Name"], reason))
225
228
    
226
229
    def selectable(self):
270
273
            else:
271
274
                timer = datetime.timedelta()
272
275
            if self.properties["ApprovedByDefault"]:
273
 
                message = "Approval in {}. (d)eny?"
 
276
                message = "Approval in {0}. (d)eny?"
274
277
            else:
275
 
                message = "Denial in {}. (a)pprove?"
 
278
                message = "Denial in {0}. (a)pprove?"
276
279
            message = message.format(str(timer).rsplit(".", 1)[0])
277
280
            self.using_timer(True)
278
281
        elif self.properties["LastCheckerStatus"] != 0:
286
289
                timer = max(expires - datetime.datetime.utcnow(),
287
290
                            datetime.timedelta())
288
291
            message = ('A checker has failed! Time until client'
289
 
                       ' gets disabled: {}'
 
292
                       ' gets disabled: {0}'
290
293
                       .format(str(timer).rsplit(".", 1)[0]))
291
294
            self.using_timer(True)
292
295
        else:
293
296
            message = "enabled"
294
297
            self.using_timer(False)
295
 
        self._text = "{}{}".format(base, message)
 
298
        self._text = "{0}{1}".format(base, message)
296
299
        
297
300
        if not urwid.supports_unicode():
298
301
            self._text = self._text.encode("ascii", "replace")
373
376
        else:
374
377
            return key
375
378
    
376
 
    def properties_changed(self, interface, properties, invalidated):
377
 
        """Call self.update() if any properties changed.
 
379
    def property_changed(self, property=None, **kwargs):
 
380
        """Call self.update() if old value is not new value.
378
381
        This overrides the method from MandosClientPropertyCache"""
379
 
        old_values = { key: self.properties.get(key)
380
 
                       for key in properties.keys() }
381
 
        super(MandosClientWidget, self).properties_changed(
382
 
            interface, properties, invalidated)
383
 
        if any(old_values[key] != self.properties.get(key)
384
 
               for key in old_values):
 
382
        property_name = str(property)
 
383
        old_value = self.properties.get(property_name)
 
384
        super(MandosClientWidget, self).property_changed(
 
385
            property=property, **kwargs)
 
386
        if self.properties.get(property_name) != old_value:
385
387
            self.update()
386
388
 
387
389
 
401
403
    """This is the entire user interface - the whole screen
402
404
    with boxes, lists of client widgets, etc.
403
405
    """
404
 
    def __init__(self, max_log_length=1000, log_level=1):
 
406
    def __init__(self, max_log_length=1000):
405
407
        DBusGMainLoop(set_as_default=True)
406
408
        
407
409
        self.screen = urwid.curses_display.Screen()
445
447
        self.log = []
446
448
        self.max_log_length = max_log_length
447
449
        
448
 
        self.log_level = log_level
449
 
        
450
450
        # We keep a reference to the log widget so we can remove it
451
451
        # from the ListWalker without it getting destroyed
452
452
        self.logbox = ConstrainedListBox(self.log)
466
466
        self.main_loop = gobject.MainLoop()
467
467
    
468
468
    def client_not_found(self, fingerprint, address):
469
 
        self.log_message("Client with address {} and fingerprint {}"
470
 
                         " could not be found"
 
469
        self.log_message("Client with address {0} and fingerprint"
 
470
                         " {1} could not be found"
471
471
                         .format(address, fingerprint))
472
472
    
473
473
    def rebuild(self):
486
486
            self.uilist.append(self.logbox)
487
487
        self.topwidget = urwid.Pile(self.uilist)
488
488
    
489
 
    def log_message(self, message, level=1):
 
489
    def log_message(self, message):
490
490
        """Log message formatted with timestamp"""
491
 
        if level < self.log_level:
492
 
            return
493
491
        timestamp = datetime.datetime.now().isoformat()
494
 
        self.log_message_raw("{}: {}".format(timestamp, message),
495
 
                             level=level)
 
492
        self.log_message_raw(timestamp + ": " + message)
496
493
    
497
 
    def log_message_raw(self, markup, level=1):
 
494
    def log_message_raw(self, markup):
498
495
        """Add a log message to the log buffer."""
499
 
        if level < self.log_level:
500
 
            return
501
496
        self.log.append(urwid.Text(markup, wrap=self.log_wrap))
502
497
        if (self.max_log_length
503
498
            and len(self.log) > self.max_log_length):
510
505
        """Toggle visibility of the log buffer."""
511
506
        self.log_visible = not self.log_visible
512
507
        self.rebuild()
513
 
        self.log_message("Log visibility changed to: {}"
514
 
                         .format(self.log_visible), level=0)
 
508
        #self.log_message("Log visibility changed to: "
 
509
        #                 + str(self.log_visible))
515
510
    
516
511
    def change_log_display(self):
517
512
        """Change type of log display.
522
517
            self.log_wrap = "clip"
523
518
        for textwidget in self.log:
524
519
            textwidget.set_wrap_mode(self.log_wrap)
525
 
        self.log_message("Wrap mode: {}".format(self.log_wrap),
526
 
                         level=0)
 
520
        #self.log_message("Wrap mode: " + self.log_wrap)
527
521
    
528
522
    def find_and_remove_client(self, path, name):
529
523
        """Find a client by its object path and remove it.
534
528
            client = self.clients_dict[path]
535
529
        except KeyError:
536
530
            # not found?
537
 
            self.log_message("Unknown client {!r} ({!r}) removed"
 
531
            self.log_message("Unknown client {0!r} ({1!r}) removed"
538
532
                             .format(name, path))
539
533
            return
540
534
        client.delete()
658
652
            elif key == "window resize":
659
653
                self.size = self.screen.get_cols_rows()
660
654
                self.refresh()
661
 
            elif key == "ctrl l":
662
 
                self.screen.clear()
 
655
            elif key == "\f":  # Ctrl-L
663
656
                self.refresh()
664
657
            elif key == "l" or key == "D":
665
658
                self.toggle_log_display()
677
670
                                            "?: Help",
678
671
                                            "l: Log window toggle",
679
672
                                            "TAB: Switch window",
680
 
                                            "w: Wrap (log lines)",
681
 
                                            "v: Toggle verbose log",
682
 
                                            ))))
 
673
                                            "w: Wrap (log)"))))
683
674
                self.log_message_raw(("bold",
684
675
                                      "  "
685
676
                                      .join(("Clients:",
698
689
                else:
699
690
                    self.topwidget.set_focus(self.logbox)
700
691
                self.refresh()
701
 
            elif key == "v":
702
 
                if self.log_level == 0:
703
 
                    self.log_level = 1
704
 
                    self.log_message("Verbose mode: Off")
705
 
                else:
706
 
                    self.log_level = 0
707
 
                    self.log_message("Verbose mode: On")
708
692
            #elif (key == "end" or key == "meta >" or key == "G"
709
693
            #      or key == ">"):
710
694
            #    pass            # xxx end-of-buffer