/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 at recompile
  • Date: 2012-01-02 01:58:41 UTC
  • Revision ID: teddy@recompile.se-20120102015841-2krpl2epdhishtpg
* mandos: Consistent terminology; use the term "secret" for the
          client's stored data.
  (ClientDBus.__init__): Removed dead code.
  (Clienthandler.handle): Bug fix: send NewRequest signal with only IP
                          address, not str() of address tuple.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-monitor
52
52
domain = 'se.recompile'
53
53
server_interface = domain + '.Mandos'
54
54
client_interface = domain + '.Mandos.Client'
55
 
version = "1.5.3"
 
55
version = "1.5.1"
56
56
 
57
57
# Always run in monochrome mode
58
58
urwid.curses_display.curses.has_colors = lambda : False
131
131
        
132
132
        self._update_timer_callback_tag = None
133
133
        self._update_timer_callback_lock = 0
 
134
        self.last_checker_failed = False
134
135
        
135
136
        # The widget shown normally
136
137
        self._text_widget = urwid.Text("")
144
145
        
145
146
        last_checked_ok = isoformat_to_datetime(self.properties
146
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"]))
147
157
        
148
 
        if self.properties ["LastCheckerStatus"] != 0:
 
158
        if self.last_checker_failed:
149
159
            self.using_timer(True)
150
160
        
151
161
        if self.need_approval:
172
182
                                         self.rejected,
173
183
                                         client_interface,
174
184
                                         byte_arrays=True))
175
 
        #self.logger('Created client {0}'
176
 
        #            .format(self.properties["Name"]))
 
185
        #self.logger('Created client %s' % (self.properties["Name"]))
177
186
    
178
187
    def property_changed(self, property=None, value=None):
179
188
        super(self, MandosClientWidget).property_changed(property,
180
189
                                                         value)
181
190
        if property == "ApprovalPending":
182
191
            using_timer(bool(value))
183
 
        if property == "LastCheckerStatus":
184
 
            using_timer(value != 0)
185
 
            #self.logger('Checker for client {0} (command "{1}") was '
186
 
            #            ' successful'.format(self.properties["Name"],
187
 
            #                                 command))
188
 
    
 
192
        
189
193
    def using_timer(self, flag):
190
194
        """Call this method with True or False when timer should be
191
195
        activated or deactivated.
206
210
    
207
211
    def checker_completed(self, exitstatus, condition, command):
208
212
        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))
209
219
            self.update()
210
220
            return
211
221
        # Checker failed
 
222
        if not self.last_checker_failed:
 
223
            self.last_checker_failed = True
 
224
            self.using_timer(True)
212
225
        if os.WIFEXITED(condition):
213
 
            self.logger('Checker for client {0} (command "{1}")'
214
 
                        ' failed with exit code {2}'
215
 
                        .format(self.properties["Name"], command,
216
 
                                os.WEXITSTATUS(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)))
217
230
        elif os.WIFSIGNALED(condition):
218
 
            self.logger('Checker for client {0} (command "{1}") was'
219
 
                        ' killed by signal {2}'
220
 
                        .format(self.properties["Name"], command,
221
 
                                os.WTERMSIG(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)))
222
235
        elif os.WCOREDUMP(condition):
223
 
            self.logger('Checker for client {0} (command "{1}")'
 
236
            self.logger('Checker for client %s (command "%s")'
224
237
                        ' dumped core'
225
 
                        .format(self.properties["Name"], command))
 
238
                        % (self.properties["Name"], command))
226
239
        else:
227
 
            self.logger('Checker for client {0} completed'
228
 
                        ' mysteriously'
229
 
                        .format(self.properties["Name"]))
 
240
            self.logger('Checker for client %s completed'
 
241
                        ' mysteriously')
230
242
        self.update()
231
243
    
232
244
    def checker_started(self, command):
233
245
        """Server signals that a checker started. This could be useful
234
246
           to log in the future. """
235
 
        #self.logger('Client {0} started checker "{1}"'
236
 
        #            .format(self.properties["Name"],
237
 
        #                    unicode(command)))
 
247
        #self.logger('Client %s started checker "%s"'
 
248
        #            % (self.properties["Name"], unicode(command)))
238
249
        pass
239
250
    
240
251
    def got_secret(self):
241
 
        self.logger('Client {0} received its secret'
242
 
                    .format(self.properties["Name"]))
 
252
        self.last_checker_failed = False
 
253
        self.logger('Client %s received its secret'
 
254
                    % self.properties["Name"])
243
255
    
244
256
    def need_approval(self, timeout, default):
245
257
        if not default:
246
 
            message = 'Client {0} needs approval within {1} seconds'
 
258
            message = 'Client %s needs approval within %s seconds'
247
259
        else:
248
 
            message = 'Client {0} will get its secret in {1} seconds'
249
 
        self.logger(message.format(self.properties["Name"],
250
 
                                   timeout/1000))
 
260
            message = 'Client %s will get its secret in %s seconds'
 
261
        self.logger(message
 
262
                    % (self.properties["Name"], timeout/1000))
251
263
        self.using_timer(True)
252
264
    
253
265
    def rejected(self, reason):
254
 
        self.logger('Client {0} was rejected; reason: {1}'
255
 
                    .format(self.properties["Name"], reason))
 
266
        self.logger('Client %s was rejected; reason: %s'
 
267
                    % (self.properties["Name"], reason))
256
268
    
257
269
    def selectable(self):
258
270
        """Make this a "selectable" widget.
284
296
        # Rebuild focus and non-focus widgets using current properties
285
297
 
286
298
        # Base part of a client. Name!
287
 
        base = '{name}: '.format(name=self.properties["Name"])
 
299
        base = ('%(name)s: '
 
300
                      % {"name": self.properties["Name"]})
288
301
        if not self.properties["Enabled"]:
289
302
            message = "DISABLED"
290
303
        elif self.properties["ApprovalPending"]:
299
312
            else:
300
313
                timer = datetime.timedelta()
301
314
            if self.properties["ApprovedByDefault"]:
302
 
                message = "Approval in {0}. (d)eny?"
 
315
                message = "Approval in %s. (d)eny?"
303
316
            else:
304
 
                message = "Denial in {0}. (a)pprove?"
305
 
            message = message.format(unicode(timer).rsplit(".", 1)[0])
306
 
        elif self.properties["LastCheckerStatus"] != 0:
 
317
                message = "Denial in %s. (a)pprove?"
 
318
            message = message % unicode(timer).rsplit(".", 1)[0]
 
319
        elif self.last_checker_failed:
307
320
            # When checker has failed, print a timer until client expires
308
321
            expires = self.properties["Expires"]
309
322
            if expires == "":
313
326
                                                     '%Y-%m-%dT%H:%M:%S.%f')
314
327
                timer = expires - datetime.datetime.utcnow()
315
328
            message = ('A checker has failed! Time until client'
316
 
                       ' gets disabled: {0}'
317
 
                       .format(unicode(timer).rsplit(".", 1)[0]))
 
329
                       ' gets disabled: %s'
 
330
                           % unicode(timer).rsplit(".", 1)[0])
318
331
        else:
319
332
            message = "enabled"
320
 
        self._text = "{0}{1}".format(base, message)
 
333
        self._text = "%s%s" % (base, message)
321
334
            
322
335
        if not urwid.supports_unicode():
323
336
            self._text = self._text.encode("ascii", "replace")
488
501
        self.main_loop = gobject.MainLoop()
489
502
    
490
503
    def client_not_found(self, fingerprint, address):
491
 
        self.log_message("Client with address {0} and fingerprint"
492
 
                         " {1} could not be found"
493
 
                         .format(address, fingerprint))
 
504
        self.log_message(("Client with address %s and fingerprint %s"
 
505
                          " could not be found" % (address,
 
506
                                                    fingerprint)))
494
507
    
495
508
    def rebuild(self):
496
509
        """This rebuilds the User Interface.
549
562
            client = self.clients_dict[path]
550
563
        except KeyError:
551
564
            # not found?
552
 
            self.log_message("Unknown client {0!r} ({1!r}) removed"
553
 
                             .format(name, path))
 
565
            self.log_message("Unknown client %r (%r) removed", name,
 
566
                             path)
554
567
            return
555
568
        client.delete()
556
569