/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-17 03:17:22 UTC
  • mfrom: (719 trunk)
  • mto: This revision was merged to the branch mainline in revision 720.
  • Revision ID: teddy@recompile.se-20140717031722-whllsy5muoaefh4i
Merge from trunk.

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-2015 Teddy Hogeborn
7
 
# Copyright © 2009-2015 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
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.6"
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 {}'
 
164
        self.logger('Created client {0}'
161
165
                    .format(self.properties["Name"]), level=0)
162
166
    
163
167
    def using_timer(self, flag):
175
179
    
176
180
    def checker_completed(self, exitstatus, condition, command):
177
181
        if exitstatus == 0:
178
 
            self.logger('Checker for client {} (command "{}")'
 
182
            self.logger('Checker for client {0} (command "{1}")'
179
183
                        ' succeeded'.format(self.properties["Name"],
180
184
                                            command), level=0)
181
185
            self.update()
182
186
            return
183
187
        # Checker failed
184
188
        if os.WIFEXITED(condition):
185
 
            self.logger('Checker for client {} (command "{}") failed'
186
 
                        ' with exit code {}'
 
189
            self.logger('Checker for client {0} (command "{1}")'
 
190
                        ' failed with exit code {2}'
187
191
                        .format(self.properties["Name"], command,
188
192
                                os.WEXITSTATUS(condition)))
189
193
        elif os.WIFSIGNALED(condition):
190
 
            self.logger('Checker for client {} (command "{}") was'
191
 
                        ' killed by signal {}'
 
194
            self.logger('Checker for client {0} (command "{1}") was'
 
195
                        ' killed by signal {2}'
192
196
                        .format(self.properties["Name"], command,
193
197
                                os.WTERMSIG(condition)))
 
198
        elif os.WCOREDUMP(condition):
 
199
            self.logger('Checker for client {0} (command "{1}")'
 
200
                        ' dumped core'
 
201
                        .format(self.properties["Name"], command))
 
202
        else:
 
203
            self.logger('Checker for client {0} completed'
 
204
                        ' mysteriously'
 
205
                        .format(self.properties["Name"]))
194
206
        self.update()
195
207
    
196
208
    def checker_started(self, command):
197
209
        """Server signals that a checker started."""
198
 
        self.logger('Client {} started checker "{}"'
 
210
        self.logger('Client {0} started checker "{1}"'
199
211
                    .format(self.properties["Name"],
200
212
                            command), level=0)
201
213
    
202
214
    def got_secret(self):
203
 
        self.logger('Client {} received its secret'
 
215
        self.logger('Client {0} received its secret'
204
216
                    .format(self.properties["Name"]))
205
217
    
206
218
    def need_approval(self, timeout, default):
207
219
        if not default:
208
 
            message = 'Client {} needs approval within {} seconds'
 
220
            message = 'Client {0} needs approval within {1} seconds'
209
221
        else:
210
 
            message = 'Client {} will get its secret in {} seconds'
 
222
            message = 'Client {0} will get its secret in {1} seconds'
211
223
        self.logger(message.format(self.properties["Name"],
212
224
                                   timeout/1000))
213
225
    
214
226
    def rejected(self, reason):
215
 
        self.logger('Client {} was rejected; reason: {}'
 
227
        self.logger('Client {0} was rejected; reason: {1}'
216
228
                    .format(self.properties["Name"], reason))
217
229
    
218
230
    def selectable(self):
262
274
            else:
263
275
                timer = datetime.timedelta()
264
276
            if self.properties["ApprovedByDefault"]:
265
 
                message = "Approval in {}. (d)eny?"
 
277
                message = "Approval in {0}. (d)eny?"
266
278
            else:
267
 
                message = "Denial in {}. (a)pprove?"
 
279
                message = "Denial in {0}. (a)pprove?"
268
280
            message = message.format(str(timer).rsplit(".", 1)[0])
269
281
            self.using_timer(True)
270
282
        elif self.properties["LastCheckerStatus"] != 0:
278
290
                timer = max(expires - datetime.datetime.utcnow(),
279
291
                            datetime.timedelta())
280
292
            message = ('A checker has failed! Time until client'
281
 
                       ' gets disabled: {}'
 
293
                       ' gets disabled: {0}'
282
294
                       .format(str(timer).rsplit(".", 1)[0]))
283
295
            self.using_timer(True)
284
296
        else:
285
297
            message = "enabled"
286
298
            self.using_timer(False)
287
 
        self._text = "{}{}".format(base, message)
 
299
        self._text = "{0}{1}".format(base, message)
288
300
        
289
301
        if not urwid.supports_unicode():
290
302
            self._text = self._text.encode("ascii", "replace")
329
341
        """Handle keys.
330
342
        This overrides the method from urwid.FlowWidget"""
331
343
        if key == "+":
332
 
            self.proxy.Set(client_interface, "Enabled",
333
 
                           dbus.Boolean(True), ignore_reply = True,
334
 
                           dbus_interface = dbus.PROPERTIES_IFACE)
 
344
            self.proxy.Enable(dbus_interface = client_interface,
 
345
                              ignore_reply=True)
335
346
        elif key == "-":
336
 
            self.proxy.Set(client_interface, "Enabled", False,
337
 
                           ignore_reply = True,
338
 
                           dbus_interface = dbus.PROPERTIES_IFACE)
 
347
            self.proxy.Disable(dbus_interface = client_interface,
 
348
                               ignore_reply=True)
339
349
        elif key == "a":
340
350
            self.proxy.Approve(dbus.Boolean(True, variant_level=1),
341
351
                               dbus_interface = client_interface,
349
359
                                                  .object_path,
350
360
                                                  ignore_reply=True)
351
361
        elif key == "s":
352
 
            self.proxy.Set(client_interface, "CheckerRunning",
353
 
                           dbus.Boolean(True), ignore_reply = True,
354
 
                           dbus_interface = dbus.PROPERTIES_IFACE)
 
362
            self.proxy.StartChecker(dbus_interface = client_interface,
 
363
                                    ignore_reply=True)
355
364
        elif key == "S":
356
 
            self.proxy.Set(client_interface, "CheckerRunning",
357
 
                           dbus.Boolean(False), ignore_reply = True,
358
 
                           dbus_interface = dbus.PROPERTIES_IFACE)
 
365
            self.proxy.StopChecker(dbus_interface = client_interface,
 
366
                                   ignore_reply=True)
359
367
        elif key == "C":
360
368
            self.proxy.CheckedOK(dbus_interface = client_interface,
361
369
                                 ignore_reply=True)
369
377
        else:
370
378
            return key
371
379
    
372
 
    def properties_changed(self, interface, properties, invalidated):
373
 
        """Call self.update() if any properties changed.
 
380
    def property_changed(self, property=None, **kwargs):
 
381
        """Call self.update() if old value is not new value.
374
382
        This overrides the method from MandosClientPropertyCache"""
375
 
        old_values = { key: self.properties.get(key)
376
 
                       for key in properties.keys() }
377
 
        super(MandosClientWidget, self).properties_changed(
378
 
            interface, properties, invalidated)
379
 
        if any(old_values[key] != self.properties.get(key)
380
 
               for key in old_values):
 
383
        property_name = str(property)
 
384
        old_value = self.properties.get(property_name)
 
385
        super(MandosClientWidget, self).property_changed(
 
386
            property=property, **kwargs)
 
387
        if self.properties.get(property_name) != old_value:
381
388
            self.update()
382
389
 
383
390
 
462
469
        self.main_loop = gobject.MainLoop()
463
470
    
464
471
    def client_not_found(self, fingerprint, address):
465
 
        self.log_message("Client with address {} and fingerprint {}"
466
 
                         " could not be found"
 
472
        self.log_message("Client with address {0} and fingerprint"
 
473
                         " {1} could not be found"
467
474
                         .format(address, fingerprint))
468
475
    
469
476
    def rebuild(self):
487
494
        if level < self.log_level:
488
495
            return
489
496
        timestamp = datetime.datetime.now().isoformat()
490
 
        self.log_message_raw("{}: {}".format(timestamp, message),
 
497
        self.log_message_raw("{0}: {1}".format(timestamp, message),
491
498
                             level=level)
492
499
    
493
500
    def log_message_raw(self, markup, level=1):
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: {}"
 
516
        self.log_message("Log visibility changed to: {0}"
510
517
                         .format(self.log_visible), level=0)
511
518
    
512
519
    def change_log_display(self):
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: {}".format(self.log_wrap),
 
528
        self.log_message("Wrap mode: {0}".format(self.log_wrap),
522
529
                         level=0)
523
530
    
524
531
    def find_and_remove_client(self, path, name):
530
537
            client = self.clients_dict[path]
531
538
        except KeyError:
532
539
            # not found?
533
 
            self.log_message("Unknown client {!r} ({!r}) removed"
 
540
            self.log_message("Unknown client {0!r} ({1!r}) removed"
534
541
                             .format(name, path))
535
542
            return
536
543
        client.delete()
654
661
            elif key == "window resize":
655
662
                self.size = self.screen.get_cols_rows()
656
663
                self.refresh()
657
 
            elif key == "ctrl l":
658
 
                self.screen.clear()
 
664
            elif key == "\f":  # Ctrl-L
659
665
                self.refresh()
660
666
            elif key == "l" or key == "D":
661
667
                self.toggle_log_display()