/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

* mandos (DBusObjectWithProperties.Introspect): Use
  itertools.chain.from_iterable(foo) instead of itertools.chain(*foo).

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-2011 Teddy Hogeborn
7
 
# Copyright © 2009-2011 Björn Påhlsson
 
6
# Copyright © 2009-2012 Teddy Hogeborn
 
7
# Copyright © 2009-2012 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
17
17
#     GNU General Public License for more details.
18
18
# 
19
19
# You should have received a copy of the GNU General Public License
20
 
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
20
# along with this program.  If not, see
 
21
# <http://www.gnu.org/licenses/>.
21
22
# 
22
23
# Contact the authors at <mandos@recompile.se>.
23
24
# 
52
53
domain = 'se.recompile'
53
54
server_interface = domain + '.Mandos'
54
55
client_interface = domain + '.Mandos.Client'
55
 
version = "1.4.1"
 
56
version = "1.5.3"
56
57
 
57
58
# Always run in monochrome mode
58
59
urwid.curses_display.curses.has_colors = lambda : False
131
132
        
132
133
        self._update_timer_callback_tag = None
133
134
        self._update_timer_callback_lock = 0
134
 
        self.last_checker_failed = False
135
135
        
136
136
        # The widget shown normally
137
137
        self._text_widget = urwid.Text("")
145
145
        
146
146
        last_checked_ok = isoformat_to_datetime(self.properties
147
147
                                                ["LastCheckedOK"])
148
 
        if last_checked_ok is None:
149
 
            self.last_checker_failed = True
150
 
        else:
151
 
            self.last_checker_failed = ((datetime.datetime.utcnow()
152
 
                                         - last_checked_ok)
153
 
                                        > datetime.timedelta
154
 
                                        (milliseconds=
155
 
                                         self.properties
156
 
                                         ["Interval"]))
157
148
        
158
 
        if self.last_checker_failed:
 
149
        if self.properties ["LastCheckerStatus"] != 0:
159
150
            self.using_timer(True)
160
151
        
161
152
        if self.need_approval:
182
173
                                         self.rejected,
183
174
                                         client_interface,
184
175
                                         byte_arrays=True))
185
 
        #self.logger('Created client %s' % (self.properties["Name"]))
 
176
        #self.logger('Created client {0}'
 
177
        #            .format(self.properties["Name"]))
186
178
    
187
179
    def property_changed(self, property=None, value=None):
188
180
        super(self, MandosClientWidget).property_changed(property,
189
181
                                                         value)
190
182
        if property == "ApprovalPending":
191
183
            using_timer(bool(value))
192
 
        
 
184
        if property == "LastCheckerStatus":
 
185
            using_timer(value != 0)
 
186
            #self.logger('Checker for client {0} (command "{1}") was '
 
187
            #            ' successful'.format(self.properties["Name"],
 
188
            #                                 command))
 
189
    
193
190
    def using_timer(self, flag):
194
191
        """Call this method with True or False when timer should be
195
192
        activated or deactivated.
210
207
    
211
208
    def checker_completed(self, exitstatus, condition, command):
212
209
        if exitstatus == 0:
213
 
            if self.last_checker_failed:
214
 
                self.last_checker_failed = False
215
 
                self.using_timer(False)
216
 
            #self.logger('Checker for client %s (command "%s")'
217
 
            #            ' was successful'
218
 
            #            % (self.properties["Name"], command))
219
210
            self.update()
220
211
            return
221
212
        # Checker failed
222
 
        if not self.last_checker_failed:
223
 
            self.last_checker_failed = True
224
 
            self.using_timer(True)
225
213
        if os.WIFEXITED(condition):
226
 
            self.logger('Checker for client %s (command "%s")'
227
 
                        ' failed with exit code %s'
228
 
                        % (self.properties["Name"], command,
229
 
                           os.WEXITSTATUS(condition)))
 
214
            self.logger('Checker for client {0} (command "{1}")'
 
215
                        ' failed with exit code {2}'
 
216
                        .format(self.properties["Name"], command,
 
217
                                os.WEXITSTATUS(condition)))
230
218
        elif os.WIFSIGNALED(condition):
231
 
            self.logger('Checker for client %s (command "%s")'
232
 
                        ' was killed by signal %s'
233
 
                        % (self.properties["Name"], command,
234
 
                           os.WTERMSIG(condition)))
 
219
            self.logger('Checker for client {0} (command "{1}") was'
 
220
                        ' killed by signal {2}'
 
221
                        .format(self.properties["Name"], command,
 
222
                                os.WTERMSIG(condition)))
235
223
        elif os.WCOREDUMP(condition):
236
 
            self.logger('Checker for client %s (command "%s")'
 
224
            self.logger('Checker for client {0} (command "{1}")'
237
225
                        ' dumped core'
238
 
                        % (self.properties["Name"], command))
 
226
                        .format(self.properties["Name"], command))
239
227
        else:
240
 
            self.logger('Checker for client %s completed'
241
 
                        ' mysteriously')
 
228
            self.logger('Checker for client {0} completed'
 
229
                        ' mysteriously'
 
230
                        .format(self.properties["Name"]))
242
231
        self.update()
243
232
    
244
233
    def checker_started(self, command):
245
 
        #self.logger('Client %s started checker "%s"'
246
 
        #            % (self.properties["Name"], unicode(command)))
 
234
        """Server signals that a checker started. This could be useful
 
235
           to log in the future. """
 
236
        #self.logger('Client {0} started checker "{1}"'
 
237
        #            .format(self.properties["Name"],
 
238
        #                    unicode(command)))
247
239
        pass
248
240
    
249
241
    def got_secret(self):
250
 
        self.last_checker_failed = False
251
 
        self.logger('Client %s received its secret'
252
 
                    % self.properties["Name"])
 
242
        self.logger('Client {0} received its secret'
 
243
                    .format(self.properties["Name"]))
253
244
    
254
245
    def need_approval(self, timeout, default):
255
246
        if not default:
256
 
            message = 'Client %s needs approval within %s seconds'
 
247
            message = 'Client {0} needs approval within {1} seconds'
257
248
        else:
258
 
            message = 'Client %s will get its secret in %s seconds'
259
 
        self.logger(message
260
 
                    % (self.properties["Name"], timeout/1000))
 
249
            message = 'Client {0} will get its secret in {1} seconds'
 
250
        self.logger(message.format(self.properties["Name"],
 
251
                                   timeout/1000))
261
252
        self.using_timer(True)
262
253
    
263
254
    def rejected(self, reason):
264
 
        self.logger('Client %s was rejected; reason: %s'
265
 
                    % (self.properties["Name"], reason))
 
255
        self.logger('Client {0} was rejected; reason: {1}'
 
256
                    .format(self.properties["Name"], reason))
266
257
    
267
258
    def selectable(self):
268
259
        """Make this a "selectable" widget.
294
285
        # Rebuild focus and non-focus widgets using current properties
295
286
 
296
287
        # Base part of a client. Name!
297
 
        base = ('%(name)s: '
298
 
                      % {"name": self.properties["Name"]})
 
288
        base = '{name}: '.format(name=self.properties["Name"])
299
289
        if not self.properties["Enabled"]:
300
290
            message = "DISABLED"
301
291
        elif self.properties["ApprovalPending"]:
310
300
            else:
311
301
                timer = datetime.timedelta()
312
302
            if self.properties["ApprovedByDefault"]:
313
 
                message = "Approval in %s. (d)eny?"
 
303
                message = "Approval in {0}. (d)eny?"
314
304
            else:
315
 
                message = "Denial in %s. (a)pprove?"
316
 
            message = message % unicode(timer).rsplit(".", 1)[0]
317
 
        elif self.last_checker_failed:
318
 
            # When checker has failed, print a timer until client expires
 
305
                message = "Denial in {0}. (a)pprove?"
 
306
            message = message.format(unicode(timer).rsplit(".", 1)[0])
 
307
        elif self.properties["LastCheckerStatus"] != 0:
 
308
            # When checker has failed, show timer until client expires
319
309
            expires = self.properties["Expires"]
320
310
            if expires == "":
321
311
                timer = datetime.timedelta(0)
322
312
            else:
323
 
                expires = datetime.datetime.strptime(expires,
324
 
                                                     '%Y-%m-%dT%H:%M:%S.%f')
 
313
                expires = (datetime.datetime.strptime
 
314
                           (expires, '%Y-%m-%dT%H:%M:%S.%f'))
325
315
                timer = expires - datetime.datetime.utcnow()
326
316
            message = ('A checker has failed! Time until client'
327
 
                       ' gets disabled: %s'
328
 
                           % unicode(timer).rsplit(".", 1)[0])
 
317
                       ' gets disabled: {0}'
 
318
                       .format(unicode(timer).rsplit(".", 1)[0]))
329
319
        else:
330
320
            message = "enabled"
331
 
        self._text = "%s%s" % (base, message)
 
321
        self._text = "{0}{1}".format(base, message)
332
322
            
333
323
        if not urwid.supports_unicode():
334
324
            self._text = self._text.encode("ascii", "replace")
497
487
        
498
488
        self.busname = domain + '.Mandos'
499
489
        self.main_loop = gobject.MainLoop()
500
 
        self.bus = dbus.SystemBus()
501
 
        mandos_dbus_objc = self.bus.get_object(
502
 
            self.busname, "/", follow_name_owner_changes=True)
503
 
        self.mandos_serv = dbus.Interface(mandos_dbus_objc,
504
 
                                          dbus_interface
505
 
                                          = server_interface)
506
 
        try:
507
 
            mandos_clients = (self.mandos_serv
508
 
                              .GetAllClientsWithProperties())
509
 
        except dbus.exceptions.DBusException:
510
 
            mandos_clients = dbus.Dictionary()
511
 
        
512
 
        (self.mandos_serv
513
 
         .connect_to_signal("ClientRemoved",
514
 
                            self.find_and_remove_client,
515
 
                            dbus_interface=server_interface,
516
 
                            byte_arrays=True))
517
 
        (self.mandos_serv
518
 
         .connect_to_signal("ClientAdded",
519
 
                            self.add_new_client,
520
 
                            dbus_interface=server_interface,
521
 
                            byte_arrays=True))
522
 
        (self.mandos_serv
523
 
         .connect_to_signal("ClientNotFound",
524
 
                            self.client_not_found,
525
 
                            dbus_interface=server_interface,
526
 
                            byte_arrays=True))
527
 
        for path, client in mandos_clients.iteritems():
528
 
            client_proxy_object = self.bus.get_object(self.busname,
529
 
                                                      path)
530
 
            self.add_client(MandosClientWidget(server_proxy_object
531
 
                                               =self.mandos_serv,
532
 
                                               proxy_object
533
 
                                               =client_proxy_object,
534
 
                                               properties=client,
535
 
                                               update_hook
536
 
                                               =self.refresh,
537
 
                                               delete_hook
538
 
                                               =self.remove_client,
539
 
                                               logger
540
 
                                               =self.log_message),
541
 
                            path=path)
542
490
    
543
491
    def client_not_found(self, fingerprint, address):
544
 
        self.log_message(("Client with address %s and fingerprint %s"
545
 
                          " could not be found" % (address,
546
 
                                                    fingerprint)))
 
492
        self.log_message("Client with address {0} and fingerprint"
 
493
                         " {1} could not be found"
 
494
                         .format(address, fingerprint))
547
495
    
548
496
    def rebuild(self):
549
497
        """This rebuilds the User Interface.
559
507
                                                     self.divider)))
560
508
        if self.log_visible:
561
509
            self.uilist.append(self.logbox)
562
 
            pass
563
510
        self.topwidget = urwid.Pile(self.uilist)
564
511
    
565
512
    def log_message(self, message):
603
550
            client = self.clients_dict[path]
604
551
        except KeyError:
605
552
            # not found?
606
 
            self.log_message("Unknown client %r (%r) removed", name,
607
 
                             path)
 
553
            self.log_message("Unknown client {0!r} ({1!r}) removed"
 
554
                             .format(name, path))
608
555
            return
609
556
        client.delete()
610
557
    
649
596
    
650
597
    def run(self):
651
598
        """Start the main loop and exit when it's done."""
 
599
        self.bus = dbus.SystemBus()
 
600
        mandos_dbus_objc = self.bus.get_object(
 
601
            self.busname, "/", follow_name_owner_changes=True)
 
602
        self.mandos_serv = dbus.Interface(mandos_dbus_objc,
 
603
                                          dbus_interface
 
604
                                          = server_interface)
 
605
        try:
 
606
            mandos_clients = (self.mandos_serv
 
607
                              .GetAllClientsWithProperties())
 
608
        except dbus.exceptions.DBusException:
 
609
            mandos_clients = dbus.Dictionary()
 
610
        
 
611
        (self.mandos_serv
 
612
         .connect_to_signal("ClientRemoved",
 
613
                            self.find_and_remove_client,
 
614
                            dbus_interface=server_interface,
 
615
                            byte_arrays=True))
 
616
        (self.mandos_serv
 
617
         .connect_to_signal("ClientAdded",
 
618
                            self.add_new_client,
 
619
                            dbus_interface=server_interface,
 
620
                            byte_arrays=True))
 
621
        (self.mandos_serv
 
622
         .connect_to_signal("ClientNotFound",
 
623
                            self.client_not_found,
 
624
                            dbus_interface=server_interface,
 
625
                            byte_arrays=True))
 
626
        for path, client in mandos_clients.iteritems():
 
627
            client_proxy_object = self.bus.get_object(self.busname,
 
628
                                                      path)
 
629
            self.add_client(MandosClientWidget(server_proxy_object
 
630
                                               =self.mandos_serv,
 
631
                                               proxy_object
 
632
                                               =client_proxy_object,
 
633
                                               properties=client,
 
634
                                               update_hook
 
635
                                               =self.refresh,
 
636
                                               delete_hook
 
637
                                               =self.remove_client,
 
638
                                               logger
 
639
                                               =self.log_message),
 
640
                            path=path)
 
641
 
652
642
        self.refresh()
653
643
        self._input_callback_tag = (gobject.io_add_watch
654
644
                                    (sys.stdin.fileno(),