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 566
- compare with another revision
- download diff
- download tarball
- view history from revision 566
- Committer: Teddy Hogeborn
- Date: 2012-05-01 20:48:00 UTC
- Revision ID: teddy@recompile.se-20120501204800-0wkzdkcd3epzci45
* mandos (main): Simplify and shorten code selecting user and group ID
to switch to.
to switch to.
- files removed:
- debian/mandos-client.examples
- debian/upstream
- files modified:
- .bzrignore
added
removed
mandos-monitor
3
3
#
4
4
# Mandos Monitor - Control and monitor the Mandos server
5
5
#
6
# Copyright © 2009-2014 Teddy Hogeborn
7
# Copyright © 2009-2014 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
21
# <http://www.gnu.org/licenses/>.
20
# along with this program. If not, see <http://www.gnu.org/licenses/>.
22
21
#
23
22
# Contact the authors at <mandos@recompile.se>.
24
23
#
25
24
26
25
from __future__ import (division, absolute_import, print_function,
27
26
unicode_literals)
28
try:
29
from future_builtins import *
30
except ImportError:
31
pass
32
27
33
28
import sys
34
29
import os
30
import signal
35
31
36
32
import datetime
37
33
39
35
import urwid
40
36
41
37
from dbus.mainloop.glib import DBusGMainLoop
42
try:
43
import gobject
44
except ImportError:
45
from gi.repository import GObject as gobject
38
import gobject
46
39
47
40
import dbus
48
41
42
import UserList
43
49
44
import locale
50
45
51
if sys.version_info.major == 2:
52
str = unicode
53
54
46
locale.setlocale(locale.LC_ALL, '')
55
47
56
48
import logging
60
52
domain = 'se.recompile'
61
53
server_interface = domain + '.Mandos'
62
54
client_interface = domain + '.Mandos.Client'
63
version = "1.6.8"
55
version = "1.5.3"
56
57
# Always run in monochrome mode
58
urwid.curses_display.curses.has_colors = lambda : False
59
60
# Urwid doesn't support blinking, but we want it. Since we have no
61
# use for underline on its own, we make underline also always blink.
62
urwid.curses_display.curses.A_UNDERLINE |= (
63
urwid.curses_display.curses.A_BLINK)
64
64
65
65
def isoformat_to_datetime(iso):
66
66
"Parse an ISO 8601 date string to a datetime.datetime()"
83
83
properties and calls a hook function when any of them are
84
84
changed.
85
85
"""
86
def __init__(self, proxy_object=None, properties=None, **kwargs):
86
def __init__(self, proxy_object=None, *args, **kwargs):
87
87
self.proxy = proxy_object # Mandos Client proxy object
88
self.properties = dict() if properties is None else properties
88
89
self.properties = dict()
89
90
self.property_changed_match = (
90
91
self.proxy.connect_to_signal("PropertyChanged",
91
self._property_changed,
92
self.property_changed,
92
93
client_interface,
93
94
byte_arrays=True))
94
95
95
if properties is None:
96
self.properties.update(
97
self.proxy.GetAll(client_interface,
98
dbus_interface
99
= dbus.PROPERTIES_IFACE))
100
101
super(MandosClientPropertyCache, self).__init__(**kwargs)
102
103
def _property_changed(self, property, value):
104
"""Helper which takes positional arguments"""
105
return self.property_changed(property=property, value=value)
96
self.properties.update(
97
self.proxy.GetAll(client_interface,
98
dbus_interface = dbus.PROPERTIES_IFACE))
99
100
#XXX This breaks good super behaviour
101
# super(MandosClientPropertyCache, self).__init__(
102
# *args, **kwargs)
106
103
107
104
def property_changed(self, property=None, value=None):
108
105
"""This is called whenever we get a PropertyChanged signal
111
108
# Update properties dict with new value
112
109
self.properties[property] = value
113
110
114
def delete(self):
111
def delete(self, *args, **kwargs):
115
112
self.property_changed_match.remove()
113
super(MandosClientPropertyCache, self).__init__(
114
*args, **kwargs)
116
115
117
116
118
117
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
120
119
"""
121
120
122
121
def __init__(self, server_proxy_object=None, update_hook=None,
123
delete_hook=None, logger=None, **kwargs):
122
delete_hook=None, logger=None, *args, **kwargs):
124
123
# Called on update
125
124
self.update_hook = update_hook
126
125
# Called on delete
131
130
self.logger = logger
132
131
133
132
self._update_timer_callback_tag = None
133
self._update_timer_callback_lock = 0
134
134
135
135
# The widget shown normally
136
136
self._text_widget = urwid.Text("")
137
137
# The widget shown when we have focus
138
138
self._focus_text_widget = urwid.Text("")
139
super(MandosClientWidget, self).__init__(**kwargs)
139
super(MandosClientWidget, self).__init__(
140
update_hook=update_hook, delete_hook=delete_hook,
141
*args, **kwargs)
140
142
self.update()
141
143
self.opened = False
142
144
145
last_checked_ok = isoformat_to_datetime(self.properties
146
["LastCheckedOK"])
147
148
if self.properties ["LastCheckerStatus"] != 0:
149
self.using_timer(True)
150
151
if self.need_approval:
152
self.using_timer(True)
153
143
154
self.match_objects = (
144
155
self.proxy.connect_to_signal("CheckerCompleted",
145
156
self.checker_completed,
161
172
self.rejected,
162
173
client_interface,
163
174
byte_arrays=True))
164
self.logger('Created client {}'
165
.format(self.properties["Name"]), level=0)
175
#self.logger('Created client %s' % (self.properties["Name"]))
176
177
def property_changed(self, property=None, value=None):
178
super(self, MandosClientWidget).property_changed(property,
179
value)
180
if property == "ApprovalPending":
181
using_timer(bool(value))
182
if property == "LastCheckerStatus":
183
using_timer(value != 0)
184
#self.logger('Checker for client %s (command "%s")'
185
# ' was successful'
186
# % (self.properties["Name"], command))
166
187
167
188
def using_timer(self, flag):
168
189
"""Call this method with True or False when timer should be
169
190
activated or deactivated.
170
191
"""
171
if flag and self._update_timer_callback_tag is None:
192
old = self._update_timer_callback_lock
193
if flag:
194
self._update_timer_callback_lock += 1
195
else:
196
self._update_timer_callback_lock -= 1
197
if old == 0 and self._update_timer_callback_lock:
172
198
# Will update the shown timer value every second
173
199
self._update_timer_callback_tag = (gobject.timeout_add
174
200
(1000,
175
201
self.update_timer))
176
elif not (flag or self._update_timer_callback_tag is None):
202
elif old and self._update_timer_callback_lock == 0:
177
203
gobject.source_remove(self._update_timer_callback_tag)
178
204
self._update_timer_callback_tag = None
179
205
180
206
def checker_completed(self, exitstatus, condition, command):
181
207
if exitstatus == 0:
182
self.logger('Checker for client {} (command "{}")'
183
' succeeded'.format(self.properties["Name"],
184
command), level=0)
185
208
self.update()
186
209
return
187
210
# Checker failed
188
211
if os.WIFEXITED(condition):
189
self.logger('Checker for client {} (command "{}") failed'
190
' with exit code {}'
191
.format(self.properties["Name"], command,
192
os.WEXITSTATUS(condition)))
212
self.logger('Checker for client %s (command "%s")'
213
' failed with exit code %s'
214
% (self.properties["Name"], command,
215
os.WEXITSTATUS(condition)))
193
216
elif os.WIFSIGNALED(condition):
194
self.logger('Checker for client {} (command "{}") was'
195
' killed by signal {}'
196
.format(self.properties["Name"], command,
197
os.WTERMSIG(condition)))
217
self.logger('Checker for client %s (command "%s")'
218
' was killed by signal %s'
219
% (self.properties["Name"], command,
220
os.WTERMSIG(condition)))
198
221
elif os.WCOREDUMP(condition):
199
self.logger('Checker for client {} (command "{}") dumped'
200
' core'.format(self.properties["Name"],
201
command))
222
self.logger('Checker for client %s (command "%s")'
223
' dumped core'
224
% (self.properties["Name"], command))
202
225
else:
203
self.logger('Checker for client {} completed'
204
' mysteriously'
205
.format(self.properties["Name"]))
226
self.logger('Checker for client %s completed'
227
' mysteriously')
206
228
self.update()
207
229
208
230
def checker_started(self, command):
209
"""Server signals that a checker started."""
210
self.logger('Client {} started checker "{}"'
211
.format(self.properties["Name"],
212
command), level=0)
231
"""Server signals that a checker started. This could be useful
232
to log in the future. """
233
#self.logger('Client %s started checker "%s"'
234
# % (self.properties["Name"], unicode(command)))
235
pass
213
236
214
237
def got_secret(self):
215
self.logger('Client {} received its secret'
216
.format(self.properties["Name"]))
238
self.logger('Client %s received its secret'
239
% self.properties["Name"])
217
240
218
241
def need_approval(self, timeout, default):
219
242
if not default:
220
message = 'Client {} needs approval within {} seconds'
243
message = 'Client %s needs approval within %s seconds'
221
244
else:
222
message = 'Client {} will get its secret in {} seconds'
223
self.logger(message.format(self.properties["Name"],
224
timeout/1000))
245
message = 'Client %s will get its secret in %s seconds'
246
self.logger(message
247
% (self.properties["Name"], timeout/1000))
248
self.using_timer(True)
225
249
226
250
def rejected(self, reason):
227
self.logger('Client {} was rejected; reason: {}'
228
.format(self.properties["Name"], reason))
251
self.logger('Client %s was rejected; reason: %s'
252
% (self.properties["Name"], reason))
229
253
230
254
def selectable(self):
231
255
"""Make this a "selectable" widget.
253
277
"bold-underline-blink":
254
278
"bold-underline-blink-standout",
255
279
}
256
280
257
281
# Rebuild focus and non-focus widgets using current properties
258
282
259
283
# Base part of a client. Name!
260
base = '{name}: '.format(name=self.properties["Name"])
284
base = ('%(name)s: '
285
% {"name": self.properties["Name"]})
261
286
if not self.properties["Enabled"]:
262
287
message = "DISABLED"
263
self.using_timer(False)
264
288
elif self.properties["ApprovalPending"]:
265
289
timeout = datetime.timedelta(milliseconds
266
290
= self.properties
268
292
last_approval_request = isoformat_to_datetime(
269
293
self.properties["LastApprovalRequest"])
270
294
if last_approval_request is not None:
271
timer = max(timeout - (datetime.datetime.utcnow()
272
- last_approval_request),
273
datetime.timedelta())
295
timer = timeout - (datetime.datetime.utcnow()
296
- last_approval_request)
274
297
else:
275
298
timer = datetime.timedelta()
276
299
if self.properties["ApprovedByDefault"]:
277
message = "Approval in {}. (d)eny?"
300
message = "Approval in %s. (d)eny?"
278
301
else:
279
message = "Denial in {}. (a)pprove?"
280
message = message.format(str(timer).rsplit(".", 1)[0])
281
self.using_timer(True)
302
message = "Denial in %s. (a)pprove?"
303
message = message % unicode(timer).rsplit(".", 1)[0]
282
304
elif self.properties["LastCheckerStatus"] != 0:
283
# When checker has failed, show timer until client expires
305
# When checker has failed, print a timer until client expires
284
306
expires = self.properties["Expires"]
285
307
if expires == "":
286
308
timer = datetime.timedelta(0)
287
309
else:
288
expires = (datetime.datetime.strptime
289
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
290
timer = max(expires - datetime.datetime.utcnow(),
291
datetime.timedelta())
310
expires = datetime.datetime.strptime(expires,
311
'%Y-%m-%dT%H:%M:%S.%f')
312
timer = expires - datetime.datetime.utcnow()
292
313
message = ('A checker has failed! Time until client'
293
' gets disabled: {}'
294
.format(str(timer).rsplit(".", 1)[0]))
295
self.using_timer(True)
314
' gets disabled: %s'
315
% unicode(timer).rsplit(".", 1)[0])
296
316
else:
297
317
message = "enabled"
298
self.using_timer(False)
299
self._text = "{}{}".format(base, message)
300
318
self._text = "%s%s" % (base, message)
319
301
320
if not urwid.supports_unicode():
302
321
self._text = self._text.encode("ascii", "replace")
303
322
textlist = [("normal", self._text)]
320
339
self.update()
321
340
return True # Keep calling this
322
341
323
def delete(self, **kwargs):
342
def delete(self, *args, **kwargs):
324
343
if self._update_timer_callback_tag is not None:
325
344
gobject.source_remove(self._update_timer_callback_tag)
326
345
self._update_timer_callback_tag = None
329
348
self.match_objects = ()
330
349
if self.delete_hook is not None:
331
350
self.delete_hook(self)
332
return super(MandosClientWidget, self).delete(**kwargs)
351
return super(MandosClientWidget, self).delete(*args, **kwargs)
333
352
334
353
def render(self, maxcolrow, focus=False):
335
354
"""Render differently if we have focus.
377
396
else:
378
397
return key
379
398
380
def property_changed(self, property=None, **kwargs):
399
def property_changed(self, property=None, value=None,
400
*args, **kwargs):
381
401
"""Call self.update() if old value is not new value.
382
402
This overrides the method from MandosClientPropertyCache"""
383
property_name = str(property)
403
property_name = unicode(property)
384
404
old_value = self.properties.get(property_name)
385
405
super(MandosClientWidget, self).property_changed(
386
property=property, **kwargs)
406
property=property, value=value, *args, **kwargs)
387
407
if self.properties.get(property_name) != old_value:
388
408
self.update()
389
409
393
413
"down" key presses, thus not allowing any containing widgets to
394
414
use them as an excuse to shift focus away from this widget.
395
415
"""
396
def keypress(self, *args, **kwargs):
397
ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
416
def keypress(self, maxcolrow, key):
417
ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)
398
418
if ret in ("up", "down"):
399
419
return
400
420
return ret
404
424
"""This is the entire user interface - the whole screen
405
425
with boxes, lists of client widgets, etc.
406
426
"""
407
def __init__(self, max_log_length=1000, log_level=1):
427
def __init__(self, max_log_length=1000):
408
428
DBusGMainLoop(set_as_default=True)
409
429
410
430
self.screen = urwid.curses_display.Screen()
413
433
("normal",
414
434
"default", "default", None),
415
435
("bold",
416
"bold", "default", "bold"),
436
"default", "default", "bold"),
417
437
("underline-blink",
418
"underline,blink", "default", "underline,blink"),
438
"default", "default", "underline"),
419
439
("standout",
420
"standout", "default", "standout"),
440
"default", "default", "standout"),
421
441
("bold-underline-blink",
422
"bold,underline,blink", "default", "bold,underline,blink"),
442
"default", "default", ("bold", "underline")),
423
443
("bold-standout",
424
"bold,standout", "default", "bold,standout"),
444
"default", "default", ("bold", "standout")),
425
445
("underline-blink-standout",
426
"underline,blink,standout", "default",
427
"underline,blink,standout"),
446
"default", "default", ("underline", "standout")),
428
447
("bold-underline-blink-standout",
429
"bold,underline,blink,standout", "default",
430
"bold,underline,blink,standout"),
448
"default", "default", ("bold", "underline",
449
"standout")),
431
450
))
432
451
433
452
if urwid.supports_unicode():
448
467
self.log = []
449
468
self.max_log_length = max_log_length
450
469
451
self.log_level = log_level
452
453
470
# We keep a reference to the log widget so we can remove it
454
471
# from the ListWalker without it getting destroyed
455
472
self.logbox = ConstrainedListBox(self.log)
469
486
self.main_loop = gobject.MainLoop()
470
487
471
488
def client_not_found(self, fingerprint, address):
472
self.log_message("Client with address {} and fingerprint {}"
473
" could not be found"
474
.format(address, fingerprint))
489
self.log_message(("Client with address %s and fingerprint %s"
490
" could not be found" % (address,
491
fingerprint)))
475
492
476
493
def rebuild(self):
477
494
"""This rebuilds the User Interface.
489
506
self.uilist.append(self.logbox)
490
507
self.topwidget = urwid.Pile(self.uilist)
491
508
492
def log_message(self, message, level=1):
493
"""Log message formatted with timestamp"""
494
if level < self.log_level:
495
return
509
def log_message(self, message):
496
510
timestamp = datetime.datetime.now().isoformat()
497
self.log_message_raw("{}: {}".format(timestamp, message),
498
level=level)
511
self.log_message_raw(timestamp + ": " + message)
499
512
500
def log_message_raw(self, markup, level=1):
513
def log_message_raw(self, markup):
501
514
"""Add a log message to the log buffer."""
502
if level < self.log_level:
503
return
504
515
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
505
516
if (self.max_log_length
506
517
and len(self.log) > self.max_log_length):
513
524
"""Toggle visibility of the log buffer."""
514
525
self.log_visible = not self.log_visible
515
526
self.rebuild()
516
self.log_message("Log visibility changed to: {}"
517
.format(self.log_visible), level=0)
527
#self.log_message("Log visibility changed to: "
528
# + unicode(self.log_visible))
518
529
519
530
def change_log_display(self):
520
531
"""Change type of log display.
525
536
self.log_wrap = "clip"
526
537
for textwidget in self.log:
527
538
textwidget.set_wrap_mode(self.log_wrap)
528
self.log_message("Wrap mode: {}".format(self.log_wrap),
529
level=0)
539
#self.log_message("Wrap mode: " + self.log_wrap)
530
540
531
541
def find_and_remove_client(self, path, name):
532
542
"""Find a client by its object path and remove it.
537
547
client = self.clients_dict[path]
538
548
except KeyError:
539
549
# not found?
540
self.log_message("Unknown client {!r} ({!r}) removed"
541
.format(name, path))
550
self.log_message("Unknown client %r (%r) removed", name,
551
path)
542
552
return
543
553
client.delete()
544
554
561
571
if path is None:
562
572
path = client.proxy.object_path
563
573
self.clients_dict[path] = client
564
self.clients.sort(key=lambda c: c.properties["Name"])
574
self.clients.sort(None, lambda c: c.properties["Name"])
565
575
self.refresh()
566
576
567
577
def remove_client(self, client, path=None):
569
579
if path is None:
570
580
path = client.proxy.object_path
571
581
del self.clients_dict[path]
582
if not self.clients_dict:
583
# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
584
# is completely emptied, we need to recreate it.
585
self.clients = urwid.SimpleListWalker([])
586
self.rebuild()
572
587
self.refresh()
573
588
574
589
def refresh(self):
587
602
try:
588
603
mandos_clients = (self.mandos_serv
589
604
.GetAllClientsWithProperties())
590
if not mandos_clients:
591
self.log_message_raw(("bold", "Note: Server has no clients."))
592
605
except dbus.exceptions.DBusException:
593
self.log_message_raw(("bold", "Note: No Mandos server running."))
594
606
mandos_clients = dbus.Dictionary()
595
607
596
608
(self.mandos_serv
608
620
self.client_not_found,
609
621
dbus_interface=server_interface,
610
622
byte_arrays=True))
611
for path, client in mandos_clients.items():
623
for path, client in mandos_clients.iteritems():
612
624
client_proxy_object = self.bus.get_object(self.busname,
613
625
path)
614
626
self.add_client(MandosClientWidget(server_proxy_object
623
635
logger
624
636
=self.log_message),
625
637
path=path)
626
638
627
639
self.refresh()
628
640
self._input_callback_tag = (gobject.io_add_watch
629
641
(sys.stdin.fileno(),
661
673
elif key == "window resize":
662
674
self.size = self.screen.get_cols_rows()
663
675
self.refresh()
664
elif key == "ctrl l":
665
self.screen.clear()
676
elif key == "\f": # Ctrl-L
666
677
self.refresh()
667
678
elif key == "l" or key == "D":
668
679
self.toggle_log_display()
680
691
"?: Help",
681
692
"l: Log window toggle",
682
693
"TAB: Switch window",
683
"w: Wrap (log lines)",
684
"v: Toggle verbose log",
685
))))
694
"w: Wrap (log)"))))
686
695
self.log_message_raw(("bold",
687
696
" "
688
697
.join(("Clients:",
701
710
else:
702
711
self.topwidget.set_focus(self.logbox)
703
712
self.refresh()
704
elif key == "v":
705
if self.log_level == 0:
706
self.log_level = 1
707
self.log_message("Verbose mode: Off")
708
else:
709
self.log_level = 0
710
self.log_message("Verbose mode: On")
711
713
#elif (key == "end" or key == "meta >" or key == "G"
712
714
# or key == ">"):
713
715
# pass # xxx end-of-buffer
736
738
ui.run()
737
739
except KeyboardInterrupt:
738
740
ui.screen.stop()
739
except Exception as e:
740
ui.log_message(str(e))
741
except Exception, e:
742
ui.log_message(unicode(e))
741
743
ui.screen.stop()
742
744
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0