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