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 748
- compare with another revision
- download diff
- download tarball
- view history from revision 748
- Committer: Teddy Hogeborn
- Date: 2015-05-23 10:41:35 UTC
- Revision ID: teddy@recompile.se-20150523104135-s08sbkurj1wf0jrz
mandos-keygen: Update copyright year.
- files added:
- initramfs-tools-hook-conf
- files removed:
- bugs.xml
- debian/tests
- dracut-module
- plugin-helpers
- 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
#
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
5
#
6
# Copyright © 2009-2014 Teddy Hogeborn
7
# Copyright © 2009-2014 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/>.
23
#
20
# along with this program. If not, see
21
# <http://www.gnu.org/licenses/>.
22
#
24
23
# Contact the authors at <mandos@recompile.se>.
25
#
24
#
26
25
27
26
from __future__ import (division, absolute_import, print_function,
28
27
unicode_literals)
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
43
40
44
41
from dbus.mainloop.glib import DBusGMainLoop
45
from gi.repository import GLib
42
try:
43
import gobject
44
except ImportError:
45
from gi.repository import GObject as gobject
46
46
47
47
import dbus
48
48
49
import locale
50
49
51
if sys.version_info.major == 2:
50
__metaclass__ = type
51
52
str = unicode
52
53
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)
54
locale.setlocale(locale.LC_ALL, '')
55
56
import logging
57
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
62
58
63
59
# Some useful constants
64
domain = "se.recompile"
65
server_interface = domain + ".Mandos"
66
client_interface = domain + ".Mandos.Client"
67
version = "1.8.9"
68
69
try:
70
dbus.OBJECT_MANAGER_IFACE
71
except AttributeError:
72
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
73
60
domain = 'se.recompile'
61
server_interface = domain + '.Mandos'
62
client_interface = domain + '.Mandos.Client'
63
version = "1.6.9"
74
64
75
65
def isoformat_to_datetime(iso):
76
66
"Parse an ISO 8601 date string to a datetime.datetime()"
85
75
int(day),
86
76
int(hour),
87
77
int(minute),
88
int(second), # Whole seconds
89
int(fraction*1000000)) # Microseconds
90
91
92
class MandosClientPropertyCache:
78
int(second), # Whole seconds
79
int(fraction*1000000)) # Microseconds
80
81
class MandosClientPropertyCache(object):
93
82
"""This wraps a Mandos Client D-Bus proxy object, caches the
94
83
properties and calls a hook function when any of them are
95
84
changed.
96
85
"""
97
86
def __init__(self, proxy_object=None, properties=None, **kwargs):
98
self.proxy = proxy_object # Mandos Client proxy object
87
self.proxy = proxy_object # Mandos Client proxy object
99
88
self.properties = dict() if properties is None else properties
100
89
self.property_changed_match = (
101
90
self.proxy.connect_to_signal("PropertiesChanged",
102
91
self.properties_changed,
103
92
dbus.PROPERTIES_IFACE,
104
93
byte_arrays=True))
105
94
106
95
if properties is None:
107
self.properties.update(self.proxy.GetAll(
108
client_interface,
109
dbus_interface=dbus.PROPERTIES_IFACE))
110
96
self.properties.update(
97
self.proxy.GetAll(client_interface,
98
dbus_interface
99
= dbus.PROPERTIES_IFACE))
100
111
101
super(MandosClientPropertyCache, self).__init__(**kwargs)
112
102
113
103
def properties_changed(self, interface, properties, invalidated):
114
104
"""This is called whenever we get a PropertiesChanged signal
115
105
It updates the changed properties in the "properties" dict.
116
106
"""
117
107
# Update properties dict with new value
118
if interface == client_interface:
119
self.properties.update(properties)
120
108
self.properties.update(properties)
109
121
110
def delete(self):
122
111
self.property_changed_match.remove()
123
112
125
114
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
126
115
"""A Mandos Client which is visible on the screen.
127
116
"""
128
117
129
118
def __init__(self, server_proxy_object=None, update_hook=None,
130
delete_hook=None, **kwargs):
119
delete_hook=None, logger=None, **kwargs):
131
120
# Called on update
132
121
self.update_hook = update_hook
133
122
# Called on delete
134
123
self.delete_hook = delete_hook
135
124
# Mandos Server proxy object
136
125
self.server_proxy_object = server_proxy_object
137
126
# Logger
127
self.logger = logger
128
138
129
self._update_timer_callback_tag = None
139
130
140
131
# The widget shown normally
141
132
self._text_widget = urwid.Text("")
142
133
# The widget shown when we have focus
144
135
super(MandosClientWidget, self).__init__(**kwargs)
145
136
self.update()
146
137
self.opened = False
147
138
148
139
self.match_objects = (
149
140
self.proxy.connect_to_signal("CheckerCompleted",
150
141
self.checker_completed,
166
157
self.rejected,
167
158
client_interface,
168
159
byte_arrays=True))
169
log.debug("Created client %s", self.properties["Name"])
170
160
self.logger('Created client {}'
161
.format(self.properties["Name"]), level=0)
162
171
163
def using_timer(self, flag):
172
164
"""Call this method with True or False when timer should be
173
165
activated or deactivated.
174
166
"""
175
167
if flag and self._update_timer_callback_tag is None:
176
168
# 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)))
169
self._update_timer_callback_tag = (gobject.timeout_add
170
(1000,
171
self.update_timer))
180
172
elif not (flag or self._update_timer_callback_tag is None):
181
GLib.source_remove(self._update_timer_callback_tag)
173
gobject.source_remove(self._update_timer_callback_tag)
182
174
self._update_timer_callback_tag = None
183
175
184
176
def checker_completed(self, exitstatus, condition, command):
185
177
if exitstatus == 0:
186
log.debug('Checker for client %s (command "%s")'
187
" succeeded", self.properties["Name"], command)
178
self.logger('Checker for client {} (command "{}")'
179
' succeeded'.format(self.properties["Name"],
180
command), level=0)
188
181
self.update()
189
182
return
190
183
# Checker failed
191
184
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))
185
self.logger('Checker for client {} (command "{}") failed'
186
' with exit code {}'
187
.format(self.properties["Name"], command,
188
os.WEXITSTATUS(condition)))
195
189
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))
190
self.logger('Checker for client {} (command "{}") was'
191
' killed by signal {}'
192
.format(self.properties["Name"], command,
193
os.WTERMSIG(condition)))
194
elif os.WCOREDUMP(condition):
195
self.logger('Checker for client {} (command "{}") dumped'
196
' core'.format(self.properties["Name"],
197
command))
198
else:
199
self.logger('Checker for client {} completed'
200
' mysteriously'
201
.format(self.properties["Name"]))
199
202
self.update()
200
203
201
204
def checker_started(self, command):
202
205
"""Server signals that a checker started."""
203
log.debug('Client %s started checker "%s"',
204
self.properties["Name"], command)
205
206
self.logger('Client {} started checker "{}"'
207
.format(self.properties["Name"],
208
command), level=0)
209
206
210
def got_secret(self):
207
log.info("Client %s received its secret",
208
self.properties["Name"])
209
211
self.logger('Client {} received its secret'
212
.format(self.properties["Name"]))
213
210
214
def need_approval(self, timeout, default):
211
215
if not default:
212
message = "Client %s needs approval within %f seconds"
216
message = 'Client {} needs approval within {} seconds'
213
217
else:
214
message = "Client %s will get its secret in %f seconds"
215
log.info(message, self.properties["Name"], timeout/1000)
216
218
message = 'Client {} will get its secret in {} seconds'
219
self.logger(message.format(self.properties["Name"],
220
timeout/1000))
221
217
222
def rejected(self, reason):
218
log.info("Client %s was rejected; reason: %s",
219
self.properties["Name"], reason)
220
223
self.logger('Client {} was rejected; reason: {}'
224
.format(self.properties["Name"], reason))
225
221
226
def selectable(self):
222
227
"""Make this a "selectable" widget.
223
228
This overrides the method from urwid.FlowWidget."""
224
229
return True
225
230
226
231
def rows(self, maxcolrow, focus=False):
227
232
"""How many rows this widget will occupy might depend on
228
233
whether we have focus or not.
229
234
This overrides the method from urwid.FlowWidget"""
230
235
return self.current_widget(focus).rows(maxcolrow, focus=focus)
231
236
232
237
def current_widget(self, focus=False):
233
238
if focus or self.opened:
234
239
return self._focus_widget
235
240
return self._widget
236
241
237
242
def update(self):
238
243
"Called when what is visible on the screen should be updated."
239
244
# How to add standout mode to a style
240
with_standout = {"normal": "standout",
241
"bold": "bold-standout",
242
"underline-blink":
243
"underline-blink-standout",
244
"bold-underline-blink":
245
"bold-underline-blink-standout",
246
}
247
245
with_standout = { "normal": "standout",
246
"bold": "bold-standout",
247
"underline-blink":
248
"underline-blink-standout",
249
"bold-underline-blink":
250
"bold-underline-blink-standout",
251
}
252
248
253
# Rebuild focus and non-focus widgets using current properties
249
254
250
255
# Base part of a client. Name!
251
base = "{name}: ".format(name=self.properties["Name"])
256
base = '{name}: '.format(name=self.properties["Name"])
252
257
if not self.properties["Enabled"]:
253
258
message = "DISABLED"
254
259
self.using_timer(False)
255
260
elif self.properties["ApprovalPending"]:
256
timeout = datetime.timedelta(
257
milliseconds=self.properties["ApprovalDelay"])
261
timeout = datetime.timedelta(milliseconds
262
= self.properties
263
["ApprovalDelay"])
258
264
last_approval_request = isoformat_to_datetime(
259
265
self.properties["LastApprovalRequest"])
260
266
if last_approval_request is not None:
276
282
timer = datetime.timedelta(0)
277
283
else:
278
284
expires = (datetime.datetime.strptime
279
(expires, "%Y-%m-%dT%H:%M:%S.%f"))
285
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
280
286
timer = max(expires - datetime.datetime.utcnow(),
281
287
datetime.timedelta())
282
message = ("A checker has failed! Time until client"
283
" gets disabled: {}"
288
message = ('A checker has failed! Time until client'
289
' gets disabled: {}'
284
290
.format(str(timer).rsplit(".", 1)[0]))
285
291
self.using_timer(True)
286
292
else:
287
293
message = "enabled"
288
294
self.using_timer(False)
289
295
self._text = "{}{}".format(base, message)
290
296
291
297
if not urwid.supports_unicode():
292
298
self._text = self._text.encode("ascii", "replace")
293
299
textlist = [("normal", self._text)]
303
309
# Run update hook, if any
304
310
if self.update_hook is not None:
305
311
self.update_hook()
306
312
307
313
def update_timer(self):
308
"""called by GLib. Will indefinitely loop until
309
GLib.source_remove() on tag is called
310
"""
314
"""called by gobject. Will indefinitely loop until
315
gobject.source_remove() on tag is called"""
311
316
self.update()
312
317
return True # Keep calling this
313
318
314
319
def delete(self, **kwargs):
315
320
if self._update_timer_callback_tag is not None:
316
GLib.source_remove(self._update_timer_callback_tag)
321
gobject.source_remove(self._update_timer_callback_tag)
317
322
self._update_timer_callback_tag = None
318
323
for match in self.match_objects:
319
324
match.remove()
321
326
if self.delete_hook is not None:
322
327
self.delete_hook(self)
323
328
return super(MandosClientWidget, self).delete(**kwargs)
324
329
325
330
def render(self, maxcolrow, focus=False):
326
331
"""Render differently if we have focus.
327
332
This overrides the method from urwid.FlowWidget"""
328
333
return self.current_widget(focus).render(maxcolrow,
329
334
focus=focus)
330
335
331
336
def keypress(self, maxcolrow, key):
332
337
"""Handle keys.
333
338
This overrides the method from urwid.FlowWidget"""
334
339
if key == "+":
335
self.proxy.Set(client_interface, "Enabled",
336
dbus.Boolean(True), ignore_reply=True,
337
dbus_interface=dbus.PROPERTIES_IFACE)
340
self.proxy.Enable(dbus_interface = client_interface,
341
ignore_reply=True)
338
342
elif key == "-":
339
self.proxy.Set(client_interface, "Enabled", False,
340
ignore_reply=True,
341
dbus_interface=dbus.PROPERTIES_IFACE)
343
self.proxy.Disable(dbus_interface = client_interface,
344
ignore_reply=True)
342
345
elif key == "a":
343
346
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
344
dbus_interface=client_interface,
347
dbus_interface = client_interface,
345
348
ignore_reply=True)
346
349
elif key == "d":
347
350
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
348
dbus_interface=client_interface,
351
dbus_interface = client_interface,
349
352
ignore_reply=True)
350
353
elif key == "R" or key == "_" or key == "ctrl k":
351
354
self.server_proxy_object.RemoveClient(self.proxy
352
355
.object_path,
353
356
ignore_reply=True)
354
357
elif key == "s":
355
self.proxy.Set(client_interface, "CheckerRunning",
356
dbus.Boolean(True), ignore_reply=True,
357
dbus_interface=dbus.PROPERTIES_IFACE)
358
self.proxy.StartChecker(dbus_interface = client_interface,
359
ignore_reply=True)
358
360
elif key == "S":
359
self.proxy.Set(client_interface, "CheckerRunning",
360
dbus.Boolean(False), ignore_reply=True,
361
dbus_interface=dbus.PROPERTIES_IFACE)
361
self.proxy.StopChecker(dbus_interface = client_interface,
362
ignore_reply=True)
362
363
elif key == "C":
363
self.proxy.CheckedOK(dbus_interface=client_interface,
364
self.proxy.CheckedOK(dbus_interface = client_interface,
364
365
ignore_reply=True)
365
366
# xxx
366
367
# elif key == "p" or key == "=":
371
372
# self.open()
372
373
else:
373
374
return key
374
375
375
376
def properties_changed(self, interface, properties, invalidated):
376
377
"""Call self.update() if any properties changed.
377
378
This overrides the method from MandosClientPropertyCache"""
378
old_values = {key: self.properties.get(key)
379
for key in properties.keys()}
379
old_values = { key: self.properties.get(key)
380
for key in properties.keys() }
380
381
super(MandosClientWidget, self).properties_changed(
381
382
interface, properties, invalidated)
382
383
if any(old_values[key] != self.properties.get(key)
384
385
self.update()
385
386
386
387
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
388
class ConstrainedListBox(urwid.ListBox):
398
389
"""Like a normal urwid.ListBox, but will consume all "up" or
399
390
"down" key presses, thus not allowing any containing widgets to
400
391
use them as an excuse to shift focus away from this widget.
401
392
"""
402
393
def keypress(self, *args, **kwargs):
403
ret = (super(ConstrainedListBox, self)
404
.keypress(*args, **kwargs))
394
ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
405
395
if ret in ("up", "down"):
406
396
return
407
397
return ret
408
398
409
399
410
class UserInterface:
400
class UserInterface(object):
411
401
"""This is the entire user interface - the whole screen
412
402
with boxes, lists of client widgets, etc.
413
403
"""
414
def __init__(self, max_log_length=1000):
404
def __init__(self, max_log_length=1000, log_level=1):
415
405
DBusGMainLoop(set_as_default=True)
416
406
417
407
self.screen = urwid.curses_display.Screen()
418
408
419
409
self.screen.register_palette((
420
410
("normal",
421
411
"default", "default", None),
426
416
("standout",
427
417
"standout", "default", "standout"),
428
418
("bold-underline-blink",
429
"bold,underline,blink", "default",
430
"bold,underline,blink"),
419
"bold,underline,blink", "default", "bold,underline,blink"),
431
420
("bold-standout",
432
421
"bold,standout", "default", "bold,standout"),
433
422
("underline-blink-standout",
437
426
"bold,underline,blink,standout", "default",
438
427
"bold,underline,blink,standout"),
439
428
))
440
429
441
430
if urwid.supports_unicode():
442
self.divider = "─" # \u2500
431
self.divider = "─" # \u2500
432
#self.divider = "━" # \u2501
443
433
else:
444
self.divider = "_" # \u005f
445
434
#self.divider = "-" # \u002d
435
self.divider = "_" # \u005f
436
446
437
self.screen.start()
447
438
448
439
self.size = self.screen.get_cols_rows()
449
440
450
441
self.clients = urwid.SimpleListWalker([])
451
442
self.clients_dict = {}
452
443
453
444
# We will add Text widgets to this list
454
self.log = urwid.SimpleListWalker([])
445
self.log = []
455
446
self.max_log_length = max_log_length
456
447
448
self.log_level = log_level
449
457
450
# We keep a reference to the log widget so we can remove it
458
451
# from the ListWalker without it getting destroyed
459
452
self.logbox = ConstrainedListBox(self.log)
460
453
461
454
# This keeps track of whether self.uilist currently has
462
455
# self.logbox in it or not
463
456
self.log_visible = True
464
457
self.log_wrap = "any"
465
466
self.loghandler = UILogHandler(self)
467
458
468
459
self.rebuild()
469
self.add_log_line(("bold",
470
"Mandos Monitor version " + version))
471
self.add_log_line(("bold", "q: Quit ?: Help"))
472
473
self.busname = domain + ".Mandos"
474
self.main_loop = GLib.MainLoop()
475
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)
479
460
self.log_message_raw(("bold",
461
"Mandos Monitor version " + version))
462
self.log_message_raw(("bold",
463
"q: Quit ?: Help"))
464
465
self.busname = domain + '.Mandos'
466
self.main_loop = gobject.MainLoop()
467
468
def client_not_found(self, fingerprint, address):
469
self.log_message("Client with address {} and fingerprint {}"
470
" could not be found"
471
.format(address, fingerprint))
472
480
473
def rebuild(self):
481
474
"""This rebuilds the User Interface.
482
475
Call this when the widget layout needs to change"""
483
476
self.uilist = []
484
# self.uilist.append(urwid.ListBox(self.clients))
477
#self.uilist.append(urwid.ListBox(self.clients))
485
478
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
486
479
clients),
487
# header=urwid.Divider(),
480
#header=urwid.Divider(),
488
481
header=None,
489
footer=urwid.Divider(
490
div_char=self.divider)))
482
footer=
483
urwid.Divider(div_char=
484
self.divider)))
491
485
if self.log_visible:
492
486
self.uilist.append(self.logbox)
493
487
self.topwidget = urwid.Pile(self.uilist)
494
495
def add_log_line(self, markup):
488
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
if self.max_log_length:
498
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,
502
if (self.max_log_length
503
and len(self.log) > self.max_log_length):
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
504
509
def toggle_log_display(self):
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)
509
513
self.log_message("Log visibility changed to: {}"
514
.format(self.log_visible), level=0)
515
510
516
def change_log_display(self):
511
517
"""Change type of log display.
512
518
Currently, this toggles wrapping of text lines."""
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)
520
521
def find_and_remove_client(self, path, interfaces):
525
self.log_message("Wrap mode: {}".format(self.log_wrap),
526
level=0)
527
528
def find_and_remove_client(self, path, name):
522
529
"""Find a client by its object path and remove it.
523
524
This is connected to the InterfacesRemoved signal from the
530
531
This is connected to the ClientRemoved signal from the
525
532
Mandos server object."""
526
if client_interface not in interfaces:
527
# Not a Mandos client object; ignore
528
return
529
533
try:
530
534
client = self.clients_dict[path]
531
535
except KeyError:
532
536
# not found?
533
log.warning("Unknown client %s removed", path)
537
self.log_message("Unknown client {!r} ({!r}) removed"
538
.format(name, path))
534
539
return
535
540
client.delete()
536
537
def add_new_client(self, path, ifs_and_props):
538
"""Find a client by its object path and remove it.
539
540
This is connected to the InterfacesAdded signal from the
541
Mandos server object.
542
"""
543
if client_interface not in ifs_and_props:
544
# Not a Mandos client object; ignore
545
return
541
542
def add_new_client(self, path):
546
543
client_proxy_object = self.bus.get_object(self.busname, path)
547
self.add_client(MandosClientWidget(
548
server_proxy_object=self.mandos_serv,
549
proxy_object=client_proxy_object,
550
update_hook=self.refresh,
551
delete_hook=self.remove_client,
552
properties=dict(ifs_and_props[client_interface])),
544
self.add_client(MandosClientWidget(server_proxy_object
545
=self.mandos_serv,
546
proxy_object
547
=client_proxy_object,
548
update_hook
549
=self.refresh,
550
delete_hook
551
=self.remove_client,
552
logger
553
=self.log_message),
553
554
path=path)
554
555
555
556
def add_client(self, client, path=None):
556
557
self.clients.append(client)
557
558
if path is None:
559
560
self.clients_dict[path] = client
560
561
self.clients.sort(key=lambda c: c.properties["Name"])
561
562
self.refresh()
562
563
563
564
def remove_client(self, client, path=None):
564
565
self.clients.remove(client)
565
566
if path is None:
566
567
path = client.proxy.object_path
567
568
del self.clients_dict[path]
568
569
self.refresh()
569
570
570
571
def refresh(self):
571
572
"""Redraw the screen"""
572
573
canvas = self.topwidget.render(self.size, focus=True)
573
574
self.screen.draw_screen(self.size, canvas)
574
575
575
576
def run(self):
576
577
"""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
578
self.bus = dbus.SystemBus()
583
579
mandos_dbus_objc = self.bus.get_object(
584
580
self.busname, "/", follow_name_owner_changes=True)
585
self.mandos_serv = dbus.Interface(
586
mandos_dbus_objc, dbus_interface=server_interface)
581
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
582
dbus_interface
583
= server_interface)
587
584
try:
588
585
mandos_clients = (self.mandos_serv
589
586
.GetAllClientsWithProperties())
590
587
if not mandos_clients:
591
log.warning("Note: Server has no clients.")
588
self.log_message_raw(("bold", "Note: Server has no clients."))
592
589
except dbus.exceptions.DBusException:
593
log.warning("Note: No Mandos server running.")
590
self.log_message_raw(("bold", "Note: No Mandos server running."))
594
591
mandos_clients = dbus.Dictionary()
595
592
596
593
(self.mandos_serv
597
.connect_to_signal("InterfacesRemoved",
594
.connect_to_signal("ClientRemoved",
598
595
self.find_and_remove_client,
599
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
596
dbus_interface=server_interface,
600
597
byte_arrays=True))
601
598
(self.mandos_serv
602
.connect_to_signal("InterfacesAdded",
599
.connect_to_signal("ClientAdded",
603
600
self.add_new_client,
604
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
601
dbus_interface=server_interface,
605
602
byte_arrays=True))
606
603
(self.mandos_serv
607
604
.connect_to_signal("ClientNotFound",
611
608
for path, client in mandos_clients.items():
612
609
client_proxy_object = self.bus.get_object(self.busname,
613
610
path)
614
self.add_client(MandosClientWidget(
615
server_proxy_object=self.mandos_serv,
616
proxy_object=client_proxy_object,
617
properties=client,
618
update_hook=self.refresh,
619
delete_hook=self.remove_client),
611
self.add_client(MandosClientWidget(server_proxy_object
612
=self.mandos_serv,
613
proxy_object
614
=client_proxy_object,
615
properties=client,
616
update_hook
617
=self.refresh,
618
delete_hook
619
=self.remove_client,
620
logger
621
=self.log_message),
620
622
path=path)
621
623
622
624
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)))
625
self._input_callback_tag = (gobject.io_add_watch
626
(sys.stdin.fileno(),
627
gobject.IO_IN,
628
self.process_input))
628
629
self.main_loop.run()
629
630
# Main loop has finished, we should close everything now
630
GLib.source_remove(self._input_callback_tag)
631
with warnings.catch_warnings():
632
warnings.simplefilter("ignore", BytesWarning)
633
self.screen.stop()
634
631
gobject.source_remove(self._input_callback_tag)
632
self.screen.stop()
633
635
634
def stop(self):
636
635
self.main_loop.quit()
637
log.removeHandler(self.loghandler)
638
log.propagate = self.orig_log_propagate
639
636
640
637
def process_input(self, source, condition):
641
638
keys = self.screen.get_input()
642
translations = {"ctrl n": "down", # Emacs
643
"ctrl p": "up", # Emacs
644
"ctrl v": "page down", # Emacs
645
"meta v": "page up", # Emacs
646
" ": "page down", # less
647
"f": "page down", # less
648
"b": "page up", # less
649
"j": "down", # vi
650
"k": "up", # vi
651
}
639
translations = { "ctrl n": "down", # Emacs
640
"ctrl p": "up", # Emacs
641
"ctrl v": "page down", # Emacs
642
"meta v": "page up", # Emacs
643
" ": "page down", # less
644
"f": "page down", # less
645
"b": "page up", # less
646
"j": "down", # vi
647
"k": "up", # vi
648
}
652
649
for key in keys:
653
650
try:
654
651
key = translations[key]
655
652
except KeyError: # :-)
656
653
pass
657
654
658
655
if key == "q" or key == "Q":
659
656
self.stop()
660
657
break
674
671
if not self.log_visible:
675
672
self.log_visible = True
676
673
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
))))
674
self.log_message_raw(("bold",
675
" ".
676
join(("q: Quit",
677
"?: Help",
678
"l: Log window toggle",
679
"TAB: Switch window",
680
"w: Wrap (log lines)",
681
"v: Toggle verbose log",
682
))))
683
self.log_message_raw(("bold",
684
" "
685
.join(("Clients:",
686
"+: Enable",
687
"-: Disable",
688
"R: Remove",
689
"s: Start new checker",
690
"S: Stop checker",
691
"C: Checker OK",
692
"a: Approve",
693
"d: Deny"))))
696
694
self.refresh()
697
695
elif key == "tab":
698
696
if self.topwidget.get_focus() is self.logbox:
701
699
self.topwidget.set_focus(self.logbox)
702
700
self.refresh()
703
701
elif key == "v":
704
if log.level < logging.INFO:
705
log.setLevel(logging.INFO)
706
log.info("Verbose mode: Off")
702
if self.log_level == 0:
703
self.log_level = 1
704
self.log_message("Verbose mode: Off")
707
705
else:
708
log.setLevel(logging.NOTSET)
709
log.info("Verbose mode: On")
710
# elif (key == "end" or key == "meta >" or key == "G"
711
# or key == ">"):
712
# pass # xxx end-of-buffer
713
# elif (key == "home" or key == "meta <" or key == "g"
714
# or key == "<"):
715
# pass # xxx beginning-of-buffer
716
# elif key == "ctrl e" or key == "$":
717
# pass # xxx move-end-of-line
718
# elif key == "ctrl a" or key == "^":
719
# pass # xxx move-beginning-of-line
720
# elif key == "ctrl b" or key == "meta (" or key == "h":
721
# pass # xxx left
722
# elif key == "ctrl f" or key == "meta )" or key == "l":
723
# pass # xxx right
724
# elif key == "a":
725
# pass # scroll up log
726
# elif key == "z":
727
# pass # scroll down log
706
self.log_level = 0
707
self.log_message("Verbose mode: On")
708
#elif (key == "end" or key == "meta >" or key == "G"
709
# or key == ">"):
710
# pass # xxx end-of-buffer
711
#elif (key == "home" or key == "meta <" or key == "g"
712
# or key == "<"):
713
# pass # xxx beginning-of-buffer
714
#elif key == "ctrl e" or key == "$":
715
# pass # xxx move-end-of-line
716
#elif key == "ctrl a" or key == "^":
717
# pass # xxx move-beginning-of-line
718
#elif key == "ctrl b" or key == "meta (" or key == "h":
719
# pass # xxx left
720
#elif key == "ctrl f" or key == "meta )" or key == "l":
721
# pass # xxx right
722
#elif key == "a":
723
# pass # scroll up log
724
#elif key == "z":
725
# pass # scroll down log
728
726
elif self.topwidget.selectable():
729
727
self.topwidget.keypress(self.size, key)
730
728
self.refresh()
731
729
return True
732
730
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
731
ui = UserInterface()
748
732
try:
749
733
ui.run()
750
734
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()
735
ui.screen.stop()
736
except Exception as e:
737
ui.log_message(str(e))
738
ui.screen.stop()
758
739
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0