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 873
- compare with another revision
- download diff
- download tarball
- view history from revision 873
- Committer: Teddy Hogeborn
- Date: 2016-08-25 17:06:42 UTC
- Revision ID: teddy@recompile.se-20160825170642-n4ough8ql1145zak
PEP8 compliance: mandos-monitor
* mandos-monitor: Add PEP8 compliance (as per the "pycodestyle" tool).
* mandos-monitor: Add PEP8 compliance (as per the "pycodestyle" tool).
- files added:
- initramfs-tools-hook-conf
- files removed:
- debian/mandos-client.templates
- debian/tests
- dracut-module
- files modified:
- .bzrignore
added
removed
mandos-monitor
1
#!/usr/bin/python3 -bbI
1
#!/usr/bin/python
2
2
# -*- mode: python; coding: utf-8 -*-
3
3
#
4
4
# Mandos Monitor - Control and monitor the Mandos server
5
5
#
6
# Copyright © 2009-2019 Teddy Hogeborn
7
# Copyright © 2009-2019 Björn Påhlsson
8
#
9
# This file is part of Mandos.
10
#
11
# Mandos is free software: you can redistribute it and/or modify it
12
# under the terms of the GNU General Public License as published by
6
# Copyright © 2009-2016 Teddy Hogeborn
7
# Copyright © 2009-2016 Björn Påhlsson
8
#
9
# This program is free software: you can redistribute it and/or modify
10
# it under the terms of the GNU General Public License as published by
13
11
# the Free Software Foundation, either version 3 of the License, or
14
12
# (at your option) any later version.
15
13
#
16
# Mandos is distributed in the hope that it will be useful, but
17
# WITHOUT ANY WARRANTY; without even the implied warranty of
14
# This program is distributed in the hope that it will be useful,
15
# but WITHOUT ANY WARRANTY; without even the implied warranty of
18
16
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19
17
# GNU General Public License for more details.
20
18
#
21
19
# You should have received a copy of the GNU General Public License
22
# along with Mandos. If not, see <http://www.gnu.org/licenses/>.
20
# along with this program. If not, see
21
# <http://www.gnu.org/licenses/>.
23
22
#
24
23
# Contact the authors at <mandos@recompile.se>.
25
24
#
33
32
34
33
import sys
35
34
import os
36
import warnings
35
37
36
import datetime
38
import locale
39
import logging
40
37
41
38
import urwid.curses_display
42
39
import urwid
46
43
47
44
import dbus
48
45
46
import locale
47
48
import logging
49
49
50
if sys.version_info.major == 2:
50
__metaclass__ = type
51
51
str = unicode
52
52
53
log = logging.getLogger(os.path.basename(sys.argv[0]))
54
logging.basicConfig(level="NOTSET", # Show all messages
55
format="%(message)s") # Show basic log messages
56
57
logging.captureWarnings(True) # Show warnings via the logging system
58
59
locale.setlocale(locale.LC_ALL, "")
60
61
logging.getLogger("dbus.proxies").setLevel(logging.CRITICAL)
53
locale.setlocale(locale.LC_ALL, '')
54
55
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
62
56
63
57
# Some useful constants
64
domain = "se.recompile"
65
server_interface = domain + ".Mandos"
66
client_interface = domain + ".Mandos.Client"
67
version = "1.8.12"
58
domain = 'se.recompile'
59
server_interface = domain + '.Mandos'
60
client_interface = domain + '.Mandos.Client'
61
version = "1.7.10"
68
62
69
63
try:
70
64
dbus.OBJECT_MANAGER_IFACE
89
83
int(fraction*1000000)) # Microseconds
90
84
91
85
92
class MandosClientPropertyCache:
86
class MandosClientPropertyCache(object):
93
87
"""This wraps a Mandos Client D-Bus proxy object, caches the
94
88
properties and calls a hook function when any of them are
95
89
changed.
127
121
"""
128
122
129
123
def __init__(self, server_proxy_object=None, update_hook=None,
130
delete_hook=None, **kwargs):
124
delete_hook=None, logger=None, **kwargs):
131
125
# Called on update
132
126
self.update_hook = update_hook
133
127
# Called on delete
134
128
self.delete_hook = delete_hook
135
129
# Mandos Server proxy object
136
130
self.server_proxy_object = server_proxy_object
131
# Logger
132
self.logger = logger
137
133
138
134
self._update_timer_callback_tag = None
139
135
166
162
self.rejected,
167
163
client_interface,
168
164
byte_arrays=True))
169
log.debug("Created client %s", self.properties["Name"])
165
self.logger('Created client {}'
166
.format(self.properties["Name"]), level=0)
170
167
171
168
def using_timer(self, flag):
172
169
"""Call this method with True or False when timer should be
174
171
"""
175
172
if flag and self._update_timer_callback_tag is None:
176
173
# Will update the shown timer value every second
177
self._update_timer_callback_tag = (
178
GLib.timeout_add(1000,
179
glib_safely(self.update_timer)))
174
self._update_timer_callback_tag = (GLib.timeout_add
175
(1000,
176
self.update_timer))
180
177
elif not (flag or self._update_timer_callback_tag is None):
181
178
GLib.source_remove(self._update_timer_callback_tag)
182
179
self._update_timer_callback_tag = None
183
180
184
181
def checker_completed(self, exitstatus, condition, command):
185
182
if exitstatus == 0:
186
log.debug('Checker for client %s (command "%s")'
187
" succeeded", self.properties["Name"], command)
183
self.logger('Checker for client {} (command "{}")'
184
' succeeded'.format(self.properties["Name"],
185
command), level=0)
188
186
self.update()
189
187
return
190
188
# Checker failed
191
189
if os.WIFEXITED(condition):
192
log.info('Checker for client %s (command "%s") failed'
193
" with exit code %d", self.properties["Name"],
194
command, os.WEXITSTATUS(condition))
190
self.logger('Checker for client {} (command "{}") failed'
191
' with exit code {}'
192
.format(self.properties["Name"], command,
193
os.WEXITSTATUS(condition)))
195
194
elif os.WIFSIGNALED(condition):
196
log.info('Checker for client %s (command "%s") was'
197
" killed by signal %d", self.properties["Name"],
198
command, os.WTERMSIG(condition))
195
self.logger('Checker for client {} (command "{}") was'
196
' killed by signal {}'
197
.format(self.properties["Name"], command,
198
os.WTERMSIG(condition)))
199
199
self.update()
200
200
201
201
def checker_started(self, command):
202
202
"""Server signals that a checker started."""
203
log.debug('Client %s started checker "%s"',
204
self.properties["Name"], command)
203
self.logger('Client {} started checker "{}"'
204
.format(self.properties["Name"],
205
command), level=0)
205
206
206
207
def got_secret(self):
207
log.info("Client %s received its secret",
208
self.properties["Name"])
208
self.logger('Client {} received its secret'
209
.format(self.properties["Name"]))
209
210
210
211
def need_approval(self, timeout, default):
211
212
if not default:
212
message = "Client %s needs approval within %f seconds"
213
message = 'Client {} needs approval within {} seconds'
213
214
else:
214
message = "Client %s will get its secret in %f seconds"
215
log.info(message, self.properties["Name"], timeout/1000)
215
message = 'Client {} will get its secret in {} seconds'
216
self.logger(message.format(self.properties["Name"],
217
timeout/1000))
216
218
217
219
def rejected(self, reason):
218
log.info("Client %s was rejected; reason: %s",
219
self.properties["Name"], reason)
220
self.logger('Client {} was rejected; reason: {}'
221
.format(self.properties["Name"], reason))
220
222
221
223
def selectable(self):
222
224
"""Make this a "selectable" widget.
248
250
# Rebuild focus and non-focus widgets using current properties
249
251
250
252
# Base part of a client. Name!
251
base = "{name}: ".format(name=self.properties["Name"])
253
base = '{name}: '.format(name=self.properties["Name"])
252
254
if not self.properties["Enabled"]:
253
255
message = "DISABLED"
254
256
self.using_timer(False)
276
278
timer = datetime.timedelta(0)
277
279
else:
278
280
expires = (datetime.datetime.strptime
279
(expires, "%Y-%m-%dT%H:%M:%S.%f"))
281
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
280
282
timer = max(expires - datetime.datetime.utcnow(),
281
283
datetime.timedelta())
282
message = ("A checker has failed! Time until client"
283
" gets disabled: {}"
284
message = ('A checker has failed! Time until client'
285
' gets disabled: {}'
284
286
.format(str(timer).rsplit(".", 1)[0]))
285
287
self.using_timer(True)
286
288
else:
384
386
self.update()
385
387
386
388
387
def glib_safely(func, retval=True):
388
def safe_func(*args, **kwargs):
389
try:
390
return func(*args, **kwargs)
391
except Exception:
392
log.exception("")
393
return retval
394
return safe_func
395
396
397
389
class ConstrainedListBox(urwid.ListBox):
398
390
"""Like a normal urwid.ListBox, but will consume all "up" or
399
391
"down" key presses, thus not allowing any containing widgets to
407
399
return ret
408
400
409
401
410
class UserInterface:
402
class UserInterface(object):
411
403
"""This is the entire user interface - the whole screen
412
404
with boxes, lists of client widgets, etc.
413
405
"""
414
def __init__(self, max_log_length=1000):
406
def __init__(self, max_log_length=1000, log_level=1):
415
407
DBusGMainLoop(set_as_default=True)
416
408
417
409
self.screen = urwid.curses_display.Screen()
451
443
self.clients_dict = {}
452
444
453
445
# We will add Text widgets to this list
454
self.log = urwid.SimpleListWalker([])
446
self.log = []
455
447
self.max_log_length = max_log_length
456
448
449
self.log_level = log_level
450
457
451
# We keep a reference to the log widget so we can remove it
458
452
# from the ListWalker without it getting destroyed
459
453
self.logbox = ConstrainedListBox(self.log)
463
457
self.log_visible = True
464
458
self.log_wrap = "any"
465
459
466
self.loghandler = UILogHandler(self)
467
468
460
self.rebuild()
469
self.add_log_line(("bold",
470
"Mandos Monitor version " + version))
471
self.add_log_line(("bold", "q: Quit ?: Help"))
461
self.log_message_raw(("bold",
462
"Mandos Monitor version " + version))
463
self.log_message_raw(("bold",
464
"q: Quit ?: Help"))
472
465
473
self.busname = domain + ".Mandos"
466
self.busname = domain + '.Mandos'
474
467
self.main_loop = GLib.MainLoop()
475
468
476
def client_not_found(self, key_id, address):
477
log.info("Client with address %s and key ID %s could"
478
" not be found", address, key_id)
469
def client_not_found(self, fingerprint, address):
470
self.log_message("Client with address {} and fingerprint {}"
471
" could not be found"
472
.format(address, fingerprint))
479
473
480
474
def rebuild(self):
481
475
"""This rebuilds the User Interface.
492
486
self.uilist.append(self.logbox)
493
487
self.topwidget = urwid.Pile(self.uilist)
494
488
495
def add_log_line(self, markup):
489
def log_message(self, message, level=1):
490
"""Log message formatted with timestamp"""
491
if level < self.log_level:
492
return
493
timestamp = datetime.datetime.now().isoformat()
494
self.log_message_raw("{}: {}".format(timestamp, message),
495
level=level)
496
497
def log_message_raw(self, markup, level=1):
498
"""Add a log message to the log buffer."""
499
if level < self.log_level:
500
return
496
501
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
497
502
if self.max_log_length:
498
503
if len(self.log) > self.max_log_length:
499
del self.log[0:(len(self.log) - self.max_log_length)]
500
self.logbox.set_focus(len(self.logbox.body.contents)-1,
504
del self.log[0:len(self.log)-self.max_log_length-1]
505
self.logbox.set_focus(len(self.logbox.body.contents),
501
506
coming_from="above")
502
507
self.refresh()
503
508
505
510
"""Toggle visibility of the log buffer."""
506
511
self.log_visible = not self.log_visible
507
512
self.rebuild()
508
log.debug("Log visibility changed to: %s", self.log_visible)
513
self.log_message("Log visibility changed to: {}"
514
.format(self.log_visible), level=0)
509
515
510
516
def change_log_display(self):
511
517
"""Change type of log display.
516
522
self.log_wrap = "clip"
517
523
for textwidget in self.log:
518
524
textwidget.set_wrap_mode(self.log_wrap)
519
log.debug("Wrap mode: %s", self.log_wrap)
525
self.log_message("Wrap mode: {}".format(self.log_wrap),
526
level=0)
520
527
521
528
def find_and_remove_client(self, path, interfaces):
522
529
"""Find a client by its object path and remove it.
530
537
client = self.clients_dict[path]
531
538
except KeyError:
532
539
# not found?
533
log.warning("Unknown client %s removed", path)
540
self.log_message("Unknown client {!r} removed"
541
.format(path))
534
542
return
535
543
client.delete()
536
544
549
557
proxy_object=client_proxy_object,
550
558
update_hook=self.refresh,
551
559
delete_hook=self.remove_client,
560
logger=self.log_message,
552
561
properties=dict(ifs_and_props[client_interface])),
553
562
path=path)
554
563
574
583
575
584
def run(self):
576
585
"""Start the main loop and exit when it's done."""
577
log.addHandler(self.loghandler)
578
self.orig_log_propagate = log.propagate
579
log.propagate = False
580
self.orig_log_level = log.level
581
log.setLevel("INFO")
582
586
self.bus = dbus.SystemBus()
583
587
mandos_dbus_objc = self.bus.get_object(
584
588
self.busname, "/", follow_name_owner_changes=True)
588
592
mandos_clients = (self.mandos_serv
589
593
.GetAllClientsWithProperties())
590
594
if not mandos_clients:
591
log.warning("Note: Server has no clients.")
595
self.log_message_raw(("bold",
596
"Note: Server has no clients."))
592
597
except dbus.exceptions.DBusException:
593
log.warning("Note: No Mandos server running.")
598
self.log_message_raw(("bold",
599
"Note: No Mandos server running."))
594
600
mandos_clients = dbus.Dictionary()
595
601
596
602
(self.mandos_serv
616
622
proxy_object=client_proxy_object,
617
623
properties=client,
618
624
update_hook=self.refresh,
619
delete_hook=self.remove_client),
625
delete_hook=self.remove_client,
626
logger=self.log_message),
620
627
path=path)
621
628
622
629
self.refresh()
623
self._input_callback_tag = (
624
GLib.io_add_watch(
625
GLib.IOChannel.unix_new(sys.stdin.fileno()),
626
GLib.PRIORITY_DEFAULT, GLib.IO_IN,
627
glib_safely(self.process_input)))
630
self._input_callback_tag = (GLib.io_add_watch
631
(sys.stdin.fileno(),
632
GLib.IO_IN,
633
self.process_input))
628
634
self.main_loop.run()
629
635
# Main loop has finished, we should close everything now
630
636
GLib.source_remove(self._input_callback_tag)
631
with warnings.catch_warnings():
632
warnings.simplefilter("ignore", BytesWarning)
633
self.screen.stop()
637
self.screen.stop()
634
638
635
639
def stop(self):
636
640
self.main_loop.quit()
637
log.removeHandler(self.loghandler)
638
log.propagate = self.orig_log_propagate
639
641
640
642
def process_input(self, source, condition):
641
643
keys = self.screen.get_input()
674
676
if not self.log_visible:
675
677
self.log_visible = True
676
678
self.rebuild()
677
self.add_log_line(("bold",
678
" ".join(("q: Quit",
679
"?: Help",
680
"l: Log window toggle",
681
"TAB: Switch window",
682
"w: Wrap (log lines)",
683
"v: Toggle verbose log",
684
))))
685
self.add_log_line(("bold",
686
" ".join(("Clients:",
687
"+: Enable",
688
"-: Disable",
689
"R: Remove",
690
"s: Start new checker",
691
"S: Stop checker",
692
"C: Checker OK",
693
"a: Approve",
694
"d: Deny",
695
))))
679
self.log_message_raw(("bold",
680
" ".
681
join(("q: Quit",
682
"?: Help",
683
"l: Log window toggle",
684
"TAB: Switch window",
685
"w: Wrap (log lines)",
686
"v: Toggle verbose log",
687
))))
688
self.log_message_raw(("bold",
689
" "
690
.join(("Clients:",
691
"+: Enable",
692
"-: Disable",
693
"R: Remove",
694
"s: Start new checker",
695
"S: Stop checker",
696
"C: Checker OK",
697
"a: Approve",
698
"d: Deny"))))
696
699
self.refresh()
697
700
elif key == "tab":
698
701
if self.topwidget.get_focus() is self.logbox:
701
704
self.topwidget.set_focus(self.logbox)
702
705
self.refresh()
703
706
elif key == "v":
704
if log.level < logging.INFO:
705
log.setLevel(logging.INFO)
706
log.info("Verbose mode: Off")
707
if self.log_level == 0:
708
self.log_level = 1
709
self.log_message("Verbose mode: Off")
707
710
else:
708
log.setLevel(logging.NOTSET)
709
log.info("Verbose mode: On")
711
self.log_level = 0
712
self.log_message("Verbose mode: On")
710
713
# elif (key == "end" or key == "meta >" or key == "G"
711
714
# or key == ">"):
712
715
# pass # xxx end-of-buffer
730
733
self.refresh()
731
734
return True
732
735
733
734
class UILogHandler(logging.Handler):
735
def __init__(self, ui, *args, **kwargs):
736
self.ui = ui
737
super(UILogHandler, self).__init__(*args, **kwargs)
738
self.setFormatter(
739
logging.Formatter("%(asctime)s: %(message)s"))
740
def emit(self, record):
741
msg = self.format(record)
742
if record.levelno > logging.INFO:
743
msg = ("bold", msg)
744
self.ui.add_log_line(msg)
745
746
747
736
ui = UserInterface()
748
737
try:
749
738
ui.run()
750
739
except KeyboardInterrupt:
751
with warnings.catch_warnings():
752
warnings.filterwarnings("ignore", "", BytesWarning)
753
ui.screen.stop()
754
except Exception:
755
with warnings.catch_warnings():
756
warnings.filterwarnings("ignore", "", BytesWarning)
757
ui.screen.stop()
740
ui.screen.stop()
741
except Exception as e:
742
ui.log_message(str(e))
743
ui.screen.stop()
758
744
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0