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 567
- compare with another revision
- download diff
- download tarball
- view history from revision 567
- Committer: Teddy Hogeborn
- Date: 2012-05-03 18:51:48 UTC
- Revision ID: teddy@recompile.se-20120503185148-gm8kzvl4z216oaij
* 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,2010 Teddy Hogeborn
7
# Copyright © 2009,2010 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.2.3"
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.
358
362
"""Handle keys.
359
363
This overrides the method from urwid.FlowWidget"""
360
364
if key == "+":
361
self.proxy.Enable(dbus_interface = client_interface)
365
self.proxy.Enable(dbus_interface = client_interface,
366
ignore_reply=True)
362
367
elif key == "-":
363
self.proxy.Disable(dbus_interface = client_interface)
368
self.proxy.Disable(dbus_interface = client_interface,
369
ignore_reply=True)
364
370
elif key == "a":
365
371
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
366
dbus_interface = client_interface)
372
dbus_interface = client_interface,
373
ignore_reply=True)
367
374
elif key == "d":
368
375
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
369
dbus_interface = client_interface)
376
dbus_interface = client_interface,
377
ignore_reply=True)
370
378
elif key == "R" or key == "_" or key == "ctrl k":
371
379
self.server_proxy_object.RemoveClient(self.proxy
372
.object_path)
380
.object_path,
381
ignore_reply=True)
373
382
elif key == "s":
374
self.proxy.StartChecker(dbus_interface = client_interface)
383
self.proxy.StartChecker(dbus_interface = client_interface,
384
ignore_reply=True)
375
385
elif key == "S":
376
self.proxy.StopChecker(dbus_interface = client_interface)
386
self.proxy.StopChecker(dbus_interface = client_interface,
387
ignore_reply=True)
377
388
elif key == "C":
378
self.proxy.CheckedOK(dbus_interface = client_interface)
389
self.proxy.CheckedOK(dbus_interface = client_interface,
390
ignore_reply=True)
379
391
# xxx
380
392
# elif key == "p" or key == "=":
381
393
# self.proxy.pause()
474
486
475
487
self.busname = domain + '.Mandos'
476
488
self.main_loop = gobject.MainLoop()
477
self.bus = dbus.SystemBus()
478
mandos_dbus_objc = self.bus.get_object(
479
self.busname, "/", follow_name_owner_changes=True)
480
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
481
dbus_interface
482
= server_interface)
483
try:
484
mandos_clients = (self.mandos_serv
485
.GetAllClientsWithProperties())
486
except dbus.exceptions.DBusException:
487
mandos_clients = dbus.Dictionary()
488
489
(self.mandos_serv
490
.connect_to_signal("ClientRemoved",
491
self.find_and_remove_client,
492
dbus_interface=server_interface,
493
byte_arrays=True))
494
(self.mandos_serv
495
.connect_to_signal("ClientAdded",
496
self.add_new_client,
497
dbus_interface=server_interface,
498
byte_arrays=True))
499
(self.mandos_serv
500
.connect_to_signal("ClientNotFound",
501
self.client_not_found,
502
dbus_interface=server_interface,
503
byte_arrays=True))
504
for path, client in mandos_clients.iteritems():
505
client_proxy_object = self.bus.get_object(self.busname,
506
path)
507
self.add_client(MandosClientWidget(server_proxy_object
508
=self.mandos_serv,
509
proxy_object
510
=client_proxy_object,
511
properties=client,
512
update_hook
513
=self.refresh,
514
delete_hook
515
=self.remove_client,
516
logger
517
=self.log_message),
518
path=path)
519
489
520
490
def client_not_found(self, fingerprint, address):
521
self.log_message(("Client with address %s and fingerprint %s"
522
" could not be found" % (address,
523
fingerprint)))
491
self.log_message("Client with address {0} and fingerprint"
492
" {1} could not be found"
493
.format(address, fingerprint))
524
494
525
495
def rebuild(self):
526
496
"""This rebuilds the User Interface.
536
506
self.divider)))
537
507
if self.log_visible:
538
508
self.uilist.append(self.logbox)
539
pass
540
509
self.topwidget = urwid.Pile(self.uilist)
541
510
542
511
def log_message(self, message):
572
541
#self.log_message("Wrap mode: " + self.log_wrap)
573
542
574
543
def find_and_remove_client(self, path, name):
575
"""Find an client from its object path and remove it.
544
"""Find a client by its object path and remove it.
576
545
577
546
This is connected to the ClientRemoved signal from the
578
547
Mandos server object."""
580
549
client = self.clients_dict[path]
581
550
except KeyError:
582
551
# not found?
552
self.log_message("Unknown client {0!r} ({1!r}) removed"
553
.format(name, path))
583
554
return
584
self.remove_client(client, path)
555
client.delete()
585
556
586
557
def add_new_client(self, path):
587
558
client_proxy_object = self.bus.get_object(self.busname, path)
624
595
625
596
def run(self):
626
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
627
641
self.refresh()
628
642
self._input_callback_tag = (gobject.io_add_watch
629
643
(sys.stdin.fileno(),
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0