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 1146
- compare with another revision
- download diff
- download tarball
- view history from revision 1146
- Committer: Teddy Hogeborn
- Date: 2019-08-04 04:30:33 UTC
- Revision ID: teddy@recompile.se-20190804043033-s0ztfrvi2383wznb
Client: Always build with LFS enabled
* Makefile (FEATURES): New; set to "-D_FILE_OFFSET_BITS=64".
(CFLAGS): Add "$(FEATURES)".
* Makefile (FEATURES): New; set to "-D_FILE_OFFSET_BITS=64".
(CFLAGS): Add "$(FEATURES)".
- files added:
- bugs.xml
- debian/tests
- debian/upstream
- dracut-module
- plugin-helpers
- files removed:
- debian/upstream-signing-key.pgp
- files modified:
- .bzrignore
added
removed
mandos-monitor
1
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-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)
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.4"
62
version = "1.8.6"
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
self.main_loop = GLib.MainLoop()
469
468
470
def client_not_found(self, fingerprint, address):
469
self.log_message("Client with address {0} and fingerprint"
470
" {1} could not be found"
471
self.log_message("Client with address {} and fingerprint {}"
472
" could not be found"
471
473
.format(address, fingerprint))
472
474
473
475
def rebuild(self):
474
476
"""This rebuilds the User Interface.
475
477
Call this when the widget layout needs to change"""
476
478
self.uilist = []
477
#self.uilist.append(urwid.ListBox(self.clients))
479
# self.uilist.append(urwid.ListBox(self.clients))
478
480
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
479
481
clients),
480
#header=urwid.Divider(),
482
# header=urwid.Divider(),
481
483
header=None,
482
footer=
483
urwid.Divider(div_char=
484
self.divider)))
484
footer=urwid.Divider(
485
div_char=self.divider)))
485
486
if self.log_visible:
486
487
self.uilist.append(self.logbox)
487
488
self.topwidget = urwid.Pile(self.uilist)
488
489
def log_message(self, message):
489
490
def log_message(self, message, level=1):
490
491
"""Log message formatted with timestamp"""
492
if level < self.log_level:
493
return
491
494
timestamp = datetime.datetime.now().isoformat()
492
self.log_message_raw(timestamp + ": " + message)
493
494
def log_message_raw(self, markup):
495
self.log_message_raw("{}: {}".format(timestamp, message),
496
level=level)
497
498
def log_message_raw(self, markup, level=1):
495
499
"""Add a log message to the log buffer."""
500
if level < self.log_level:
501
return
496
502
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),
503
if self.max_log_length:
504
if len(self.log) > self.max_log_length:
505
del self.log[0:len(self.log)-self.max_log_length-1]
506
self.logbox.set_focus(len(self.logbox.body.contents)-1,
501
507
coming_from="above")
502
508
self.refresh()
503
509
504
510
def toggle_log_display(self):
505
511
"""Toggle visibility of the log buffer."""
506
512
self.log_visible = not self.log_visible
507
513
self.rebuild()
508
#self.log_message("Log visibility changed to: "
509
# + str(self.log_visible))
510
514
self.log_message("Log visibility changed to: {}"
515
.format(self.log_visible), level=0)
516
511
517
def change_log_display(self):
512
518
"""Change type of log display.
513
519
Currently, this toggles wrapping of text lines."""
517
523
self.log_wrap = "clip"
518
524
for textwidget in self.log:
519
525
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):
526
self.log_message("Wrap mode: {}".format(self.log_wrap),
527
level=0)
528
529
def find_and_remove_client(self, path, interfaces):
523
530
"""Find a client by its object path and remove it.
524
525
This is connected to the ClientRemoved signal from the
531
532
This is connected to the InterfacesRemoved signal from the
526
533
Mandos server object."""
534
if client_interface not in interfaces:
535
# Not a Mandos client object; ignore
536
return
527
537
try:
528
538
client = self.clients_dict[path]
529
539
except KeyError:
530
540
# not found?
531
self.log_message("Unknown client {0!r} ({1!r}) removed"
532
.format(name, path))
541
self.log_message("Unknown client {!r} removed"
542
.format(path))
533
543
return
534
544
client.delete()
535
536
def add_new_client(self, path):
545
546
def add_new_client(self, path, ifs_and_props):
547
"""Find a client by its object path and remove it.
548
549
This is connected to the InterfacesAdded signal from the
550
Mandos server object.
551
"""
552
if client_interface not in ifs_and_props:
553
# Not a Mandos client object; ignore
554
return
537
555
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),
556
self.add_client(MandosClientWidget(
557
server_proxy_object=self.mandos_serv,
558
proxy_object=client_proxy_object,
559
update_hook=self.refresh,
560
delete_hook=self.remove_client,
561
logger=self.log_message,
562
properties=dict(ifs_and_props[client_interface])),
548
563
path=path)
549
564
550
565
def add_client(self, client, path=None):
551
566
self.clients.append(client)
552
567
if path is None:
554
569
self.clients_dict[path] = client
555
570
self.clients.sort(key=lambda c: c.properties["Name"])
556
571
self.refresh()
557
572
558
573
def remove_client(self, client, path=None):
559
574
self.clients.remove(client)
560
575
if path is None:
561
576
path = client.proxy.object_path
562
577
del self.clients_dict[path]
563
578
self.refresh()
564
579
565
580
def refresh(self):
566
581
"""Redraw the screen"""
567
582
canvas = self.topwidget.render(self.size, focus=True)
568
583
self.screen.draw_screen(self.size, canvas)
569
584
570
585
def run(self):
571
586
"""Start the main loop and exit when it's done."""
572
587
self.bus = dbus.SystemBus()
573
588
mandos_dbus_objc = self.bus.get_object(
574
589
self.busname, "/", follow_name_owner_changes=True)
575
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
576
dbus_interface
577
= server_interface)
590
self.mandos_serv = dbus.Interface(
591
mandos_dbus_objc, dbus_interface=server_interface)
578
592
try:
579
593
mandos_clients = (self.mandos_serv
580
594
.GetAllClientsWithProperties())
581
595
if not mandos_clients:
582
self.log_message_raw(("bold", "Note: Server has no clients."))
596
self.log_message_raw(("bold",
597
"Note: Server has no clients."))
583
598
except dbus.exceptions.DBusException:
584
self.log_message_raw(("bold", "Note: No Mandos server running."))
599
self.log_message_raw(("bold",
600
"Note: No Mandos server running."))
585
601
mandos_clients = dbus.Dictionary()
586
602
587
603
(self.mandos_serv
588
.connect_to_signal("ClientRemoved",
604
.connect_to_signal("InterfacesRemoved",
589
605
self.find_and_remove_client,
590
dbus_interface=server_interface,
606
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
591
607
byte_arrays=True))
592
608
(self.mandos_serv
593
.connect_to_signal("ClientAdded",
609
.connect_to_signal("InterfacesAdded",
594
610
self.add_new_client,
595
dbus_interface=server_interface,
611
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
596
612
byte_arrays=True))
597
613
(self.mandos_serv
598
614
.connect_to_signal("ClientNotFound",
602
618
for path, client in mandos_clients.items():
603
619
client_proxy_object = self.bus.get_object(self.busname,
604
620
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),
621
self.add_client(MandosClientWidget(
622
server_proxy_object=self.mandos_serv,
623
proxy_object=client_proxy_object,
624
properties=client,
625
update_hook=self.refresh,
626
delete_hook=self.remove_client,
627
logger=self.log_message),
616
628
path=path)
617
629
618
630
self.refresh()
619
self._input_callback_tag = (gobject.io_add_watch
631
self._input_callback_tag = (GLib.io_add_watch
620
632
(sys.stdin.fileno(),
621
gobject.IO_IN,
633
GLib.IO_IN,
622
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)
637
GLib.source_remove(self._input_callback_tag)
626
638
self.screen.stop()
627
639
628
640
def stop(self):
629
641
self.main_loop.quit()
630
642
631
643
def process_input(self, source, condition):
632
644
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
}
645
translations = {"ctrl n": "down", # Emacs
646
"ctrl p": "up", # Emacs
647
"ctrl v": "page down", # Emacs
648
"meta v": "page up", # Emacs
649
" ": "page down", # less
650
"f": "page down", # less
651
"b": "page up", # less
652
"j": "down", # vi
653
"k": "up", # vi
654
}
643
655
for key in keys:
644
656
try:
645
657
key = translations[key]
646
658
except KeyError: # :-)
647
659
pass
648
660
649
661
if key == "q" or key == "Q":
650
662
self.stop()
651
663
break
652
664
elif key == "window resize":
653
665
self.size = self.screen.get_cols_rows()
654
666
self.refresh()
655
elif key == "\f": # Ctrl-L
667
elif key == "ctrl l":
668
self.screen.clear()
656
669
self.refresh()
657
670
elif key == "l" or key == "D":
658
671
self.toggle_log_display()
670
683
"?: Help",
671
684
"l: Log window toggle",
672
685
"TAB: Switch window",
673
"w: Wrap (log)"))))
686
"w: Wrap (log lines)",
687
"v: Toggle verbose log",
688
))))
674
689
self.log_message_raw(("bold",
675
690
" "
676
691
.join(("Clients:",
689
704
else:
690
705
self.topwidget.set_focus(self.logbox)
691
706
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
707
elif key == "v":
708
if self.log_level == 0:
709
self.log_level = 1
710
self.log_message("Verbose mode: Off")
711
else:
712
self.log_level = 0
713
self.log_message("Verbose mode: On")
714
# elif (key == "end" or key == "meta >" or key == "G"
715
# or key == ">"):
716
# pass # xxx end-of-buffer
717
# elif (key == "home" or key == "meta <" or key == "g"
718
# or key == "<"):
719
# pass # xxx beginning-of-buffer
720
# elif key == "ctrl e" or key == "$":
721
# pass # xxx move-end-of-line
722
# elif key == "ctrl a" or key == "^":
723
# pass # xxx move-beginning-of-line
724
# elif key == "ctrl b" or key == "meta (" or key == "h":
725
# pass # xxx left
726
# elif key == "ctrl f" or key == "meta )" or key == "l":
727
# pass # xxx right
728
# elif key == "a":
729
# pass # scroll up log
730
# elif key == "z":
731
# pass # scroll down log
710
732
elif self.topwidget.selectable():
711
733
self.topwidget.keypress(self.size, key)
712
734
self.refresh()
713
735
return True
714
736
737
715
738
ui = UserInterface()
716
739
try:
717
740
ui.run()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0