/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 22:44:20 UTC
  • mto: This revision was merged to the branch mainline in revision 724.
  • Revision ID: teddy@recompile.se-20140725224420-4a5ct2ptt0hsc92z
Require Python 2.7.

This is in preparation for the eventual move to Python 3, which will
happen as soon as all Python modules required by Mandos are available.
The mandos-ctl and mandos-monitor programs are already portable
between Python 2.6 and Python 3 without changes; this change will
bring the requirement up to Python 2.7.

* INSTALL (Prerequisites/Libraries/Mandos Server): Document
                                                   requirement of
                                                   Python 2.7; remove
                                                   Python-argparse
                                                   which is in the
                                                   Python 2.7 standard
                                                   library.
* debian/control (Source: mandos/Build-Depends-Indep): Depend on
                                                       exactly the
                                                       python2.7
                                                       package and all
                                                       the Python 2.7
                                                       versions of the
                                                       python modules.
  (Package: mandos/Depends): - '' - but still depend on python (<=2.7)
                            and the generic versions of the Python
                            modules; this is for mandos-ctl and
                            mandos-monitor, both of which are
                            compatible with Python 3, and use
                            #!/usr/bin/python.
* mandos: Use #!/usr/bin/python2.7 instead of #!/usr/bin/python.

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.7.1"
64
 
 
65
 
try:
66
 
    dbus.OBJECT_MANAGER_IFACE
67
 
except AttributeError:
68
 
    dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
 
63
version = "1.6.7"
69
64
 
70
65
def isoformat_to_datetime(iso):
71
66
    "Parse an ISO 8601 date string to a datetime.datetime()"
92
87
        self.proxy = proxy_object # Mandos Client proxy object
93
88
        self.properties = dict() if properties is None else properties
94
89
        self.property_changed_match = (
95
 
            self.proxy.connect_to_signal("PropertiesChanged",
96
 
                                         self.properties_changed,
97
 
                                         dbus.PROPERTIES_IFACE,
 
90
            self.proxy.connect_to_signal("PropertyChanged",
 
91
                                         self._property_changed,
 
92
                                         client_interface,
98
93
                                         byte_arrays=True))
99
94
        
100
95
        if properties is None:
105
100
        
106
101
        super(MandosClientPropertyCache, self).__init__(**kwargs)
107
102
    
108
 
    def properties_changed(self, interface, properties, invalidated):
109
 
        """This is called whenever we get a PropertiesChanged signal
110
 
        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.
111
110
        """
112
111
        # Update properties dict with new value
113
 
        if interface == client_interface:
114
 
            self.properties.update(properties)
 
112
        self.properties[property] = value
115
113
    
116
114
    def delete(self):
117
115
        self.property_changed_match.remove()
163
161
                                         self.rejected,
164
162
                                         client_interface,
165
163
                                         byte_arrays=True))
166
 
        self.logger('Created client {}'
 
164
        self.logger('Created client {0}'
167
165
                    .format(self.properties["Name"]), level=0)
168
166
    
169
167
    def using_timer(self, flag):
181
179
    
182
180
    def checker_completed(self, exitstatus, condition, command):
183
181
        if exitstatus == 0:
184
 
            self.logger('Checker for client {} (command "{}")'
 
182
            self.logger('Checker for client {0} (command "{1}")'
185
183
                        ' succeeded'.format(self.properties["Name"],
186
184
                                            command), level=0)
187
185
            self.update()
188
186
            return
189
187
        # Checker failed
190
188
        if os.WIFEXITED(condition):
191
 
            self.logger('Checker for client {} (command "{}") failed'
192
 
                        ' with exit code {}'
 
189
            self.logger('Checker for client {0} (command "{1}")'
 
190
                        ' failed with exit code {2}'
193
191
                        .format(self.properties["Name"], command,
194
192
                                os.WEXITSTATUS(condition)))
195
193
        elif os.WIFSIGNALED(condition):
196
 
            self.logger('Checker for client {} (command "{}") was'
197
 
                        ' killed by signal {}'
 
194
            self.logger('Checker for client {0} (command "{1}") was'
 
195
                        ' killed by signal {2}'
198
196
                        .format(self.properties["Name"], command,
199
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"]))
200
206
        self.update()
201
207
    
202
208
    def checker_started(self, command):
203
209
        """Server signals that a checker started."""
204
 
        self.logger('Client {} started checker "{}"'
 
210
        self.logger('Client {0} started checker "{1}"'
205
211
                    .format(self.properties["Name"],
206
212
                            command), level=0)
207
213
    
208
214
    def got_secret(self):
209
 
        self.logger('Client {} received its secret'
 
215
        self.logger('Client {0} received its secret'
210
216
                    .format(self.properties["Name"]))
211
217
    
212
218
    def need_approval(self, timeout, default):
213
219
        if not default:
214
 
            message = 'Client {} needs approval within {} seconds'
 
220
            message = 'Client {0} needs approval within {1} seconds'
215
221
        else:
216
 
            message = 'Client {} will get its secret in {} seconds'
 
222
            message = 'Client {0} will get its secret in {1} seconds'
217
223
        self.logger(message.format(self.properties["Name"],
218
224
                                   timeout/1000))
219
225
    
220
226
    def rejected(self, reason):
221
 
        self.logger('Client {} was rejected; reason: {}'
 
227
        self.logger('Client {0} was rejected; reason: {1}'
222
228
                    .format(self.properties["Name"], reason))
223
229
    
224
230
    def selectable(self):
268
274
            else:
269
275
                timer = datetime.timedelta()
270
276
            if self.properties["ApprovedByDefault"]:
271
 
                message = "Approval in {}. (d)eny?"
 
277
                message = "Approval in {0}. (d)eny?"
272
278
            else:
273
 
                message = "Denial in {}. (a)pprove?"
 
279
                message = "Denial in {0}. (a)pprove?"
274
280
            message = message.format(str(timer).rsplit(".", 1)[0])
275
281
            self.using_timer(True)
276
282
        elif self.properties["LastCheckerStatus"] != 0:
284
290
                timer = max(expires - datetime.datetime.utcnow(),
285
291
                            datetime.timedelta())
286
292
            message = ('A checker has failed! Time until client'
287
 
                       ' gets disabled: {}'
 
293
                       ' gets disabled: {0}'
288
294
                       .format(str(timer).rsplit(".", 1)[0]))
289
295
            self.using_timer(True)
290
296
        else:
291
297
            message = "enabled"
292
298
            self.using_timer(False)
293
 
        self._text = "{}{}".format(base, message)
 
299
        self._text = "{0}{1}".format(base, message)
294
300
        
295
301
        if not urwid.supports_unicode():
296
302
            self._text = self._text.encode("ascii", "replace")
335
341
        """Handle keys.
336
342
        This overrides the method from urwid.FlowWidget"""
337
343
        if key == "+":
338
 
            self.proxy.Set(client_interface, "Enabled",
339
 
                           dbus.Boolean(True), ignore_reply = True,
340
 
                           dbus_interface = dbus.PROPERTIES_IFACE)
 
344
            self.proxy.Enable(dbus_interface = client_interface,
 
345
                              ignore_reply=True)
341
346
        elif key == "-":
342
 
            self.proxy.Set(client_interface, "Enabled", False,
343
 
                           ignore_reply = True,
344
 
                           dbus_interface = dbus.PROPERTIES_IFACE)
 
347
            self.proxy.Disable(dbus_interface = client_interface,
 
348
                               ignore_reply=True)
345
349
        elif key == "a":
346
350
            self.proxy.Approve(dbus.Boolean(True, variant_level=1),
347
351
                               dbus_interface = client_interface,
355
359
                                                  .object_path,
356
360
                                                  ignore_reply=True)
357
361
        elif key == "s":
358
 
            self.proxy.Set(client_interface, "CheckerRunning",
359
 
                           dbus.Boolean(True), ignore_reply = True,
360
 
                           dbus_interface = dbus.PROPERTIES_IFACE)
 
362
            self.proxy.StartChecker(dbus_interface = client_interface,
 
363
                                    ignore_reply=True)
361
364
        elif key == "S":
362
 
            self.proxy.Set(client_interface, "CheckerRunning",
363
 
                           dbus.Boolean(False), ignore_reply = True,
364
 
                           dbus_interface = dbus.PROPERTIES_IFACE)
 
365
            self.proxy.StopChecker(dbus_interface = client_interface,
 
366
                                   ignore_reply=True)
365
367
        elif key == "C":
366
368
            self.proxy.CheckedOK(dbus_interface = client_interface,
367
369
                                 ignore_reply=True)
375
377
        else:
376
378
            return key
377
379
    
378
 
    def properties_changed(self, interface, properties, invalidated):
379
 
        """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.
380
382
        This overrides the method from MandosClientPropertyCache"""
381
 
        old_values = { key: self.properties.get(key)
382
 
                       for key in properties.keys() }
383
 
        super(MandosClientWidget, self).properties_changed(
384
 
            interface, properties, invalidated)
385
 
        if any(old_values[key] != self.properties.get(key)
386
 
               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:
387
388
            self.update()
388
389
 
389
390
 
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 {} and fingerprint {}"
472
 
                         " could not be found"
 
472
        self.log_message("Client with address {0} and fingerprint"
 
473
                         " {1} could not be found"
473
474
                         .format(address, fingerprint))
474
475
    
475
476
    def rebuild(self):
493
494
        if level < self.log_level:
494
495
            return
495
496
        timestamp = datetime.datetime.now().isoformat()
496
 
        self.log_message_raw("{}: {}".format(timestamp, message),
 
497
        self.log_message_raw("{0}: {1}".format(timestamp, message),
497
498
                             level=level)
498
499
    
499
500
    def log_message_raw(self, markup, level=1):
512
513
        """Toggle visibility of the log buffer."""
513
514
        self.log_visible = not self.log_visible
514
515
        self.rebuild()
515
 
        self.log_message("Log visibility changed to: {}"
 
516
        self.log_message("Log visibility changed to: {0}"
516
517
                         .format(self.log_visible), level=0)
517
518
    
518
519
    def change_log_display(self):
524
525
            self.log_wrap = "clip"
525
526
        for textwidget in self.log:
526
527
            textwidget.set_wrap_mode(self.log_wrap)
527
 
        self.log_message("Wrap mode: {}".format(self.log_wrap),
 
528
        self.log_message("Wrap mode: {0}".format(self.log_wrap),
528
529
                         level=0)
529
530
    
530
 
    def find_and_remove_client(self, path, interfaces):
 
531
    def find_and_remove_client(self, path, name):
531
532
        """Find a client by its object path and remove it.
532
533
        
533
 
        This is connected to the InterfacesRemoved signal from the
 
534
        This is connected to the ClientRemoved signal from the
534
535
        Mandos server object."""
535
 
        if client_interface not in interfaces:
536
 
            # Not a Mandos client object; ignore
537
 
            return
538
536
        try:
539
537
            client = self.clients_dict[path]
540
538
        except KeyError:
541
539
            # not found?
542
 
            self.log_message("Unknown client {!r} removed"
543
 
                             .format(path))
 
540
            self.log_message("Unknown client {0!r} ({1!r}) removed"
 
541
                             .format(name, path))
544
542
            return
545
543
        client.delete()
546
544
    
547
 
    def add_new_client(self, path, ifs_and_props):
548
 
        """Find a client by its object path and remove it.
549
 
        
550
 
        This is connected to the InterfacesAdded signal from the
551
 
        Mandos server object.
552
 
        """
553
 
        if client_interface not in ifs_and_props:
554
 
            # Not a Mandos client object; ignore
555
 
            return
 
545
    def add_new_client(self, path):
556
546
        client_proxy_object = self.bus.get_object(self.busname, path)
557
547
        self.add_client(MandosClientWidget(server_proxy_object
558
548
                                           =self.mandos_serv,
563
553
                                           delete_hook
564
554
                                           =self.remove_client,
565
555
                                           logger
566
 
                                           =self.log_message,
567
 
                                           properties
568
 
                                           = dict(ifs_and_props[
569
 
                                               client_interface])),
 
556
                                           =self.log_message),
570
557
                        path=path)
571
558
    
572
559
    def add_client(self, client, path=None):
607
594
            mandos_clients = dbus.Dictionary()
608
595
        
609
596
        (self.mandos_serv
610
 
         .connect_to_signal("InterfacesRemoved",
 
597
         .connect_to_signal("ClientRemoved",
611
598
                            self.find_and_remove_client,
612
 
                            dbus_interface
613
 
                            = dbus.OBJECT_MANAGER_IFACE,
 
599
                            dbus_interface=server_interface,
614
600
                            byte_arrays=True))
615
601
        (self.mandos_serv
616
 
         .connect_to_signal("InterfacesAdded",
 
602
         .connect_to_signal("ClientAdded",
617
603
                            self.add_new_client,
618
 
                            dbus_interface
619
 
                            = dbus.OBJECT_MANAGER_IFACE,
 
604
                            dbus_interface=server_interface,
620
605
                            byte_arrays=True))
621
606
        (self.mandos_serv
622
607
         .connect_to_signal("ClientNotFound",