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