/mandos/release

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/release

« back to all changes in this revision

Viewing changes to mandos-monitor

  • Committer: Teddy Hogeborn
  • Date: 2014-08-10 14:13:02 UTC
  • mto: (237.7.304 trunk)
  • mto: This revision was merged to the branch mainline in revision 323.
  • Revision ID: teddy@recompile.se-20140810141302-8q1xaaxlh8ho5joz
Emit D-Bus "org.freedesktop.DBus.Properties.PropertiesChanged" signal.

This deprecates the "se.recompile.Mandos.Client.PropertyChanged"
signal.  The new signal also adds support for noticing changes to the
"se.recompile.Mandos.Client.Secret" write-only property.

* mandos (dbus_annotations): Fix usage example in doc string.
  (DBusObjectWithProperties.PropertiesChanged): New; from D-Bus
                                                standard.
  (ClientDBus._interface): Set early instead of later.
  (ClientDBus.notifychangeproperty): Take new "invalidate_only"
                                     parameter, and pass in _interface
                                     as a default keyword argument.
  (ClientDBus.notifychangeproperty/setter): Also emit
                                            PropertiesChanged signal;
                                            emit new value or
                                            invalidation depending on
                                            "invalidate_only".
  (ClientDBus.secret): Apply notifychangeproperty with
                       "invalidate_only=True".
  (ClientDBus._foo): Removed defunct interface annotation.
  (ClientDBus.PropertyChanged): Add annotation; this method is now
                                deprecated.
  (main/MandosDBusService.GetAllClientsWithProperties): Use dictionary
                                                        comprehension.
* DBUS-API (Mandos Client Interface/Signals/PropertyChanged): Removed.
* mandos-monitor: Use standard "PropertiesChanged" signal instead of
                  old signal "PropertyChanged".
  (MandosClientPropertyCache.__init__): Connect to signal
                                        PropertiesChanged instead of
                                        PropertyChanged.
  (MandosClientPropertyCache._property_changed): Removed.
  (MandosClientPropertyCache.property_changed): Renamed to
                                                "properties_changed"
                                                and adapted to new
                                                call signature.
  (MandosClientWidget.properties_changed): - '' -

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