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
- browse files at revision 568
- compare with another revision
- download diff
- download tarball
- view history from revision 568
- Committer: Teddy Hogeborn
- Date: 2012-05-03 19:06:02 UTC
- Revision ID: teddy@recompile.se-20120503190602-uqghef5rbpqdvybx
* mandos-monitor: Use new string format method.
- files added:
- debian/source/local-options
- network-hooks.d
- files modified:
- DBUS-API
added
removed
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
19
19
# You should have received a copy of the GNU General Public License
20
20
# along with this program. If not, see <http://www.gnu.org/licenses/>.
21
21
#
22
# Contact the authors at <mandos@fukt.bsnet.se>.
22
# Contact the authors at <mandos@recompile.se>.
23
23
#
24
24
25
from __future__ import division, absolute_import, print_function, unicode_literals
25
from __future__ import (division, absolute_import, print_function,
26
unicode_literals)
26
27
27
28
import sys
28
29
import os
48
49
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
49
50
50
51
# Some useful constants
51
domain = 'se.bsnet.fukt'
52
domain = 'se.recompile'
52
53
server_interface = domain + '.Mandos'
53
54
client_interface = domain + '.Mandos.Client'
54
version = "1.3.0"
55
version = "1.5.3"
55
56
56
57
# Always run in monochrome mode
57
58
urwid.curses_display.curses.has_colors = lambda : False
86
87
self.proxy = proxy_object # Mandos Client proxy object
87
88
88
89
self.properties = dict()
89
self.proxy.connect_to_signal("PropertyChanged",
90
self.property_changed,
91
client_interface,
92
byte_arrays=True)
90
self.property_changed_match = (
91
self.proxy.connect_to_signal("PropertyChanged",
92
self.property_changed,
93
client_interface,
94
byte_arrays=True))
93
95
94
96
self.properties.update(
95
97
self.proxy.GetAll(client_interface,
96
98
dbus_interface = dbus.PROPERTIES_IFACE))
97
99
98
#XXX This break good super behaviour!
100
#XXX This breaks good super behaviour
99
101
# super(MandosClientPropertyCache, self).__init__(
100
102
# *args, **kwargs)
101
103
105
107
"""
106
108
# Update properties dict with new value
107
109
self.properties[property] = value
110
111
def delete(self, *args, **kwargs):
112
self.property_changed_match.remove()
113
super(MandosClientPropertyCache, self).__init__(
114
*args, **kwargs)
108
115
109
116
110
117
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
124
131
125
132
self._update_timer_callback_tag = None
126
133
self._update_timer_callback_lock = 0
127
self.last_checker_failed = False
128
134
129
135
# The widget shown normally
130
136
self._text_widget = urwid.Text("")
138
144
139
145
last_checked_ok = isoformat_to_datetime(self.properties
140
146
["LastCheckedOK"])
141
if last_checked_ok is None:
142
self.last_checker_failed = True
143
else:
144
self.last_checker_failed = ((datetime.datetime.utcnow()
145
- last_checked_ok)
146
> datetime.timedelta
147
(milliseconds=
148
self.properties
149
["Interval"]))
150
147
151
if self.last_checker_failed:
148
if self.properties ["LastCheckerStatus"] != 0:
152
149
self.using_timer(True)
153
150
154
151
if self.need_approval:
155
152
self.using_timer(True)
156
153
157
self.proxy.connect_to_signal("CheckerCompleted",
158
self.checker_completed,
159
client_interface,
160
byte_arrays=True)
161
self.proxy.connect_to_signal("CheckerStarted",
162
self.checker_started,
163
client_interface,
164
byte_arrays=True)
165
self.proxy.connect_to_signal("GotSecret",
166
self.got_secret,
167
client_interface,
168
byte_arrays=True)
169
self.proxy.connect_to_signal("NeedApproval",
170
self.need_approval,
171
client_interface,
172
byte_arrays=True)
173
self.proxy.connect_to_signal("Rejected",
174
self.rejected,
175
client_interface,
176
byte_arrays=True)
154
self.match_objects = (
155
self.proxy.connect_to_signal("CheckerCompleted",
156
self.checker_completed,
157
client_interface,
158
byte_arrays=True),
159
self.proxy.connect_to_signal("CheckerStarted",
160
self.checker_started,
161
client_interface,
162
byte_arrays=True),
163
self.proxy.connect_to_signal("GotSecret",
164
self.got_secret,
165
client_interface,
166
byte_arrays=True),
167
self.proxy.connect_to_signal("NeedApproval",
168
self.need_approval,
169
client_interface,
170
byte_arrays=True),
171
self.proxy.connect_to_signal("Rejected",
172
self.rejected,
173
client_interface,
174
byte_arrays=True))
175
#self.logger('Created client {0}'
176
# .format(self.properties["Name"]))
177
177
178
178
def property_changed(self, property=None, value=None):
179
179
super(self, MandosClientWidget).property_changed(property,
180
180
value)
181
181
if property == "ApprovalPending":
182
182
using_timer(bool(value))
183
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
184
189
def using_timer(self, flag):
185
190
"""Call this method with True or False when timer should be
186
191
activated or deactivated.
191
196
else:
192
197
self._update_timer_callback_lock -= 1
193
198
if old == 0 and self._update_timer_callback_lock:
199
# Will update the shown timer value every second
194
200
self._update_timer_callback_tag = (gobject.timeout_add
195
201
(1000,
196
202
self.update_timer))
200
206
201
207
def checker_completed(self, exitstatus, condition, command):
202
208
if exitstatus == 0:
203
if self.last_checker_failed:
204
self.last_checker_failed = False
205
self.using_timer(False)
206
#self.logger('Checker for client %s (command "%s")'
207
# ' was successful'
208
# % (self.properties["Name"], command))
209
209
self.update()
210
210
return
211
211
# Checker failed
212
if not self.last_checker_failed:
213
self.last_checker_failed = True
214
self.using_timer(True)
215
212
if os.WIFEXITED(condition):
216
self.logger('Checker for client %s (command "%s")'
217
' failed with exit code %s'
218
% (self.properties["Name"], command,
219
os.WEXITSTATUS(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)))
220
217
elif os.WIFSIGNALED(condition):
221
self.logger('Checker for client %s (command "%s")'
222
' was killed by signal %s'
223
% (self.properties["Name"], command,
224
os.WTERMSIG(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)))
225
222
elif os.WCOREDUMP(condition):
226
self.logger('Checker for client %s (command "%s")'
223
self.logger('Checker for client {0} (command "{1}")'
227
224
' dumped core'
228
% (self.properties["Name"], command))
225
.format(self.properties["Name"], command))
229
226
else:
230
self.logger('Checker for client %s completed'
231
' mysteriously')
227
self.logger('Checker for client {0} completed'
228
' mysteriously'
229
.format(self.properties["Name"]))
232
230
self.update()
233
231
234
232
def checker_started(self, command):
235
#self.logger('Client %s started checker "%s"'
236
# % (self.properties["Name"], unicode(command)))
233
"""Server signals that a checker started. This could be useful
234
to log in the future. """
235
#self.logger('Client {0} started checker "{1}"'
236
# .format(self.properties["Name"],
237
# unicode(command)))
237
238
pass
238
239
239
240
def got_secret(self):
240
self.last_checker_failed = False
241
self.logger('Client %s received its secret'
242
% self.properties["Name"])
241
self.logger('Client {0} received its secret'
242
.format(self.properties["Name"]))
243
243
244
244
def need_approval(self, timeout, default):
245
245
if not default:
246
message = 'Client %s needs approval within %s seconds'
246
message = 'Client {0} needs approval within {1} seconds'
247
247
else:
248
message = 'Client %s will get its secret in %s seconds'
249
self.logger(message
250
% (self.properties["Name"], timeout/1000))
248
message = 'Client {0} will get its secret in {1} seconds'
249
self.logger(message.format(self.properties["Name"],
250
timeout/1000))
251
251
self.using_timer(True)
252
252
253
253
def rejected(self, reason):
254
self.logger('Client %s was rejected; reason: %s'
255
% (self.properties["Name"], reason))
254
self.logger('Client {0} was rejected; reason: {1}'
255
.format(self.properties["Name"], reason))
256
256
257
257
def selectable(self):
258
258
"""Make this a "selectable" widget.
284
284
# Rebuild focus and non-focus widgets using current properties
285
285
286
286
# Base part of a client. Name!
287
base = ('%(name)s: '
288
% {"name": self.properties["Name"]})
287
base = '{name}: '.format(name=self.properties["Name"])
289
288
if not self.properties["Enabled"]:
290
289
message = "DISABLED"
291
290
elif self.properties["ApprovalPending"]:
300
299
else:
301
300
timer = datetime.timedelta()
302
301
if self.properties["ApprovedByDefault"]:
303
message = "Approval in %s. (d)eny?"
304
else:
305
message = "Denial in %s. (a)pprove?"
306
message = message % unicode(timer).rsplit(".", 1)[0]
307
elif self.last_checker_failed:
308
timeout = datetime.timedelta(milliseconds
309
= self.properties
310
["Timeout"])
311
last_ok = isoformat_to_datetime(
312
max((self.properties["LastCheckedOK"]
313
or self.properties["Created"]),
314
self.properties["LastEnabled"]))
315
timer = timeout - (datetime.datetime.utcnow() - last_ok)
302
message = "Approval in {0}. (d)eny?"
303
else:
304
message = "Denial in {0}. (a)pprove?"
305
message = message.format(unicode(timer).rsplit(".", 1)[0])
306
elif self.properties["LastCheckerStatus"] != 0:
307
# When checker has failed, print a timer until client expires
308
expires = self.properties["Expires"]
309
if expires == "":
310
timer = datetime.timedelta(0)
311
else:
312
expires = datetime.datetime.strptime(expires,
313
'%Y-%m-%dT%H:%M:%S.%f')
314
timer = expires - datetime.datetime.utcnow()
316
315
message = ('A checker has failed! Time until client'
317
' gets disabled: %s'
318
% unicode(timer).rsplit(".", 1)[0])
316
' gets disabled: {0}'
317
.format(unicode(timer).rsplit(".", 1)[0]))
319
318
else:
320
319
message = "enabled"
321
self._text = "%s%s" % (base, message)
320
self._text = "{0}{1}".format(base, message)
322
321
323
322
if not urwid.supports_unicode():
324
323
self._text = self._text.encode("ascii", "replace")
337
336
self.update_hook()
338
337
339
338
def update_timer(self):
340
"called by gobject"
339
"""called by gobject. Will indefinitely loop until
340
gobject.source_remove() on tag is called"""
341
341
self.update()
342
342
return True # Keep calling this
343
343
344
def delete(self):
344
def delete(self, *args, **kwargs):
345
345
if self._update_timer_callback_tag is not None:
346
346
gobject.source_remove(self._update_timer_callback_tag)
347
347
self._update_timer_callback_tag = None
348
for match in self.match_objects:
349
match.remove()
350
self.match_objects = ()
348
351
if self.delete_hook is not None:
349
352
self.delete_hook(self)
353
return super(MandosClientWidget, self).delete(*args, **kwargs)
350
354
351
355
def render(self, maxcolrow, focus=False):
352
356
"""Render differently if we have focus.
482
486
483
487
self.busname = domain + '.Mandos'
484
488
self.main_loop = gobject.MainLoop()
485
self.bus = dbus.SystemBus()
486
mandos_dbus_objc = self.bus.get_object(
487
self.busname, "/", follow_name_owner_changes=True)
488
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
489
dbus_interface
490
= server_interface)
491
try:
492
mandos_clients = (self.mandos_serv
493
.GetAllClientsWithProperties())
494
except dbus.exceptions.DBusException:
495
mandos_clients = dbus.Dictionary()
496
497
(self.mandos_serv
498
.connect_to_signal("ClientRemoved",
499
self.find_and_remove_client,
500
dbus_interface=server_interface,
501
byte_arrays=True))
502
(self.mandos_serv
503
.connect_to_signal("ClientAdded",
504
self.add_new_client,
505
dbus_interface=server_interface,
506
byte_arrays=True))
507
(self.mandos_serv
508
.connect_to_signal("ClientNotFound",
509
self.client_not_found,
510
dbus_interface=server_interface,
511
byte_arrays=True))
512
for path, client in mandos_clients.iteritems():
513
client_proxy_object = self.bus.get_object(self.busname,
514
path)
515
self.add_client(MandosClientWidget(server_proxy_object
516
=self.mandos_serv,
517
proxy_object
518
=client_proxy_object,
519
properties=client,
520
update_hook
521
=self.refresh,
522
delete_hook
523
=self.remove_client,
524
logger
525
=self.log_message),
526
path=path)
527
489
528
490
def client_not_found(self, fingerprint, address):
529
self.log_message(("Client with address %s and fingerprint %s"
530
" could not be found" % (address,
531
fingerprint)))
491
self.log_message("Client with address {0} and fingerprint"
492
" {1} could not be found"
493
.format(address, fingerprint))
532
494
533
495
def rebuild(self):
534
496
"""This rebuilds the User Interface.
544
506
self.divider)))
545
507
if self.log_visible:
546
508
self.uilist.append(self.logbox)
547
pass
548
509
self.topwidget = urwid.Pile(self.uilist)
549
510
550
511
def log_message(self, message):
580
541
#self.log_message("Wrap mode: " + self.log_wrap)
581
542
582
543
def find_and_remove_client(self, path, name):
583
"""Find an client from its object path and remove it.
544
"""Find a client by its object path and remove it.
584
545
585
546
This is connected to the ClientRemoved signal from the
586
547
Mandos server object."""
588
549
client = self.clients_dict[path]
589
550
except KeyError:
590
551
# not found?
552
self.log_message("Unknown client {0!r} ({1!r}) removed"
553
.format(name, path))
591
554
return
592
self.remove_client(client, path)
555
client.delete()
593
556
594
557
def add_new_client(self, path):
595
558
client_proxy_object = self.bus.get_object(self.busname, path)
632
595
633
596
def run(self):
634
597
"""Start the main loop and exit when it's done."""
598
self.bus = dbus.SystemBus()
599
mandos_dbus_objc = self.bus.get_object(
600
self.busname, "/", follow_name_owner_changes=True)
601
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
602
dbus_interface
603
= server_interface)
604
try:
605
mandos_clients = (self.mandos_serv
606
.GetAllClientsWithProperties())
607
except dbus.exceptions.DBusException:
608
mandos_clients = dbus.Dictionary()
609
610
(self.mandos_serv
611
.connect_to_signal("ClientRemoved",
612
self.find_and_remove_client,
613
dbus_interface=server_interface,
614
byte_arrays=True))
615
(self.mandos_serv
616
.connect_to_signal("ClientAdded",
617
self.add_new_client,
618
dbus_interface=server_interface,
619
byte_arrays=True))
620
(self.mandos_serv
621
.connect_to_signal("ClientNotFound",
622
self.client_not_found,
623
dbus_interface=server_interface,
624
byte_arrays=True))
625
for path, client in mandos_clients.iteritems():
626
client_proxy_object = self.bus.get_object(self.busname,
627
path)
628
self.add_client(MandosClientWidget(server_proxy_object
629
=self.mandos_serv,
630
proxy_object
631
=client_proxy_object,
632
properties=client,
633
update_hook
634
=self.refresh,
635
delete_hook
636
=self.remove_client,
637
logger
638
=self.log_message),
639
path=path)
640
635
641
self.refresh()
636
642
self._input_callback_tag = (gobject.io_add_watch
637
643
(sys.stdin.fileno(),
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0