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 1122
- compare with another revision
- download diff
- download tarball
- view history from revision 1122
- Committer: Teddy Hogeborn
- Date: 2019-07-24 11:02:24 UTC
- Revision ID: teddy@recompile.se-20190724110224-i5wwdsrv2h9ic4nh
Fix bashisms: Use "command -v" instead of "type"
* Makefile (DOCBOOKTOMAN): Change "type" to "command -v".
* mandos-to-cryptroot-unlock: - '' -
* Makefile (DOCBOOKTOMAN): Change "type" to "command -v".
* mandos-to-cryptroot-unlock: - '' -
- files added:
- bugs.xml
- debian/tests
- plugin-helpers
- files removed:
- initramfs-tools-hook-conf
- 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.6"
62
version = "1.8.4"
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}'
166
self.logger('Created client {}'
165
167
.format(self.properties["Name"]), level=0)
166
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:
182
self.logger('Checker for client {0} (command "{1}")'
184
self.logger('Checker for client {} (command "{}")'
183
185
' succeeded'.format(self.properties["Name"],
184
186
command), level=0)
185
187
self.update()
186
188
return
187
189
# Checker failed
188
190
if os.WIFEXITED(condition):
189
self.logger('Checker for client {0} (command "{1}")'
190
' failed with exit code {2}'
191
self.logger('Checker for client {} (command "{}") failed'
192
' with exit code {}'
191
193
.format(self.properties["Name"], command,
192
194
os.WEXITSTATUS(condition)))
193
195
elif os.WIFSIGNALED(condition):
194
self.logger('Checker for client {0} (command "{1}") was'
195
' killed by signal {2}'
196
self.logger('Checker for client {} (command "{}") was'
197
' killed by signal {}'
196
198
.format(self.properties["Name"], command,
197
199
os.WTERMSIG(condition)))
198
elif os.WCOREDUMP(condition):
199
self.logger('Checker for client {0} (command "{1}")'
200
' dumped core'
201
.format(self.properties["Name"], command))
202
else:
203
self.logger('Checker for client {0} completed'
204
' mysteriously'
205
.format(self.properties["Name"]))
206
200
self.update()
207
201
208
202
def checker_started(self, command):
209
203
"""Server signals that a checker started."""
210
self.logger('Client {0} started checker "{1}"'
204
self.logger('Client {} started checker "{}"'
211
205
.format(self.properties["Name"],
212
206
command), level=0)
213
207
214
208
def got_secret(self):
215
self.logger('Client {0} received its secret'
209
self.logger('Client {} received its secret'
216
210
.format(self.properties["Name"]))
217
211
218
212
def need_approval(self, timeout, default):
219
213
if not default:
220
message = 'Client {0} needs approval within {1} seconds'
214
message = 'Client {} needs approval within {} seconds'
221
215
else:
222
message = 'Client {0} will get its secret in {1} seconds'
216
message = 'Client {} will get its secret in {} seconds'
223
217
self.logger(message.format(self.properties["Name"],
224
218
timeout/1000))
225
219
226
220
def rejected(self, reason):
227
self.logger('Client {0} was rejected; reason: {1}'
221
self.logger('Client {} was rejected; reason: {}'
228
222
.format(self.properties["Name"], reason))
229
223
230
224
def selectable(self):
231
225
"""Make this a "selectable" widget.
232
226
This overrides the method from urwid.FlowWidget."""
233
227
return True
234
228
235
229
def rows(self, maxcolrow, focus=False):
236
230
"""How many rows this widget will occupy might depend on
237
231
whether we have focus or not.
238
232
This overrides the method from urwid.FlowWidget"""
239
233
return self.current_widget(focus).rows(maxcolrow, focus=focus)
240
234
241
235
def current_widget(self, focus=False):
242
236
if focus or self.opened:
243
237
return self._focus_widget
244
238
return self._widget
245
239
246
240
def update(self):
247
241
"Called when what is visible on the screen should be updated."
248
242
# How to add standout mode to a style
249
with_standout = { "normal": "standout",
250
"bold": "bold-standout",
251
"underline-blink":
252
"underline-blink-standout",
253
"bold-underline-blink":
254
"bold-underline-blink-standout",
255
}
256
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
257
251
# Rebuild focus and non-focus widgets using current properties
258
252
259
253
# Base part of a client. Name!
260
254
base = '{name}: '.format(name=self.properties["Name"])
261
255
if not self.properties["Enabled"]:
262
256
message = "DISABLED"
263
257
self.using_timer(False)
264
258
elif self.properties["ApprovalPending"]:
265
timeout = datetime.timedelta(milliseconds
266
= self.properties
267
["ApprovalDelay"])
259
timeout = datetime.timedelta(
260
milliseconds=self.properties["ApprovalDelay"])
268
261
last_approval_request = isoformat_to_datetime(
269
262
self.properties["LastApprovalRequest"])
270
263
if last_approval_request is not None:
274
267
else:
275
268
timer = datetime.timedelta()
276
269
if self.properties["ApprovedByDefault"]:
277
message = "Approval in {0}. (d)eny?"
270
message = "Approval in {}. (d)eny?"
278
271
else:
279
message = "Denial in {0}. (a)pprove?"
272
message = "Denial in {}. (a)pprove?"
280
273
message = message.format(str(timer).rsplit(".", 1)[0])
281
274
self.using_timer(True)
282
275
elif self.properties["LastCheckerStatus"] != 0:
290
283
timer = max(expires - datetime.datetime.utcnow(),
291
284
datetime.timedelta())
292
285
message = ('A checker has failed! Time until client'
293
' gets disabled: {0}'
286
' gets disabled: {}'
294
287
.format(str(timer).rsplit(".", 1)[0]))
295
288
self.using_timer(True)
296
289
else:
297
290
message = "enabled"
298
291
self.using_timer(False)
299
self._text = "{0}{1}".format(base, message)
300
292
self._text = "{}{}".format(base, message)
293
301
294
if not urwid.supports_unicode():
302
295
self._text = self._text.encode("ascii", "replace")
303
296
textlist = [("normal", self._text)]
313
306
# Run update hook, if any
314
307
if self.update_hook is not None:
315
308
self.update_hook()
316
309
317
310
def update_timer(self):
318
"""called by gobject. Will indefinitely loop until
319
gobject.source_remove() on tag is called"""
311
"""called by GLib. Will indefinitely loop until
312
GLib.source_remove() on tag is called
313
"""
320
314
self.update()
321
315
return True # Keep calling this
322
316
323
317
def delete(self, **kwargs):
324
318
if self._update_timer_callback_tag is not None:
325
gobject.source_remove(self._update_timer_callback_tag)
319
GLib.source_remove(self._update_timer_callback_tag)
326
320
self._update_timer_callback_tag = None
327
321
for match in self.match_objects:
328
322
match.remove()
330
324
if self.delete_hook is not None:
331
325
self.delete_hook(self)
332
326
return super(MandosClientWidget, self).delete(**kwargs)
333
327
334
328
def render(self, maxcolrow, focus=False):
335
329
"""Render differently if we have focus.
336
330
This overrides the method from urwid.FlowWidget"""
337
331
return self.current_widget(focus).render(maxcolrow,
338
332
focus=focus)
339
333
340
334
def keypress(self, maxcolrow, key):
341
335
"""Handle keys.
342
336
This overrides the method from urwid.FlowWidget"""
343
337
if key == "+":
344
self.proxy.Enable(dbus_interface = client_interface,
345
ignore_reply=True)
338
self.proxy.Set(client_interface, "Enabled",
339
dbus.Boolean(True), ignore_reply=True,
340
dbus_interface=dbus.PROPERTIES_IFACE)
346
341
elif key == "-":
347
self.proxy.Disable(dbus_interface = client_interface,
348
ignore_reply=True)
342
self.proxy.Set(client_interface, "Enabled", False,
343
ignore_reply=True,
344
dbus_interface=dbus.PROPERTIES_IFACE)
349
345
elif key == "a":
350
346
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
351
dbus_interface = client_interface,
347
dbus_interface=client_interface,
352
348
ignore_reply=True)
353
349
elif key == "d":
354
350
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
355
dbus_interface = client_interface,
351
dbus_interface=client_interface,
356
352
ignore_reply=True)
357
353
elif key == "R" or key == "_" or key == "ctrl k":
358
354
self.server_proxy_object.RemoveClient(self.proxy
359
355
.object_path,
360
356
ignore_reply=True)
361
357
elif key == "s":
362
self.proxy.StartChecker(dbus_interface = client_interface,
363
ignore_reply=True)
358
self.proxy.Set(client_interface, "CheckerRunning",
359
dbus.Boolean(True), ignore_reply=True,
360
dbus_interface=dbus.PROPERTIES_IFACE)
364
361
elif key == "S":
365
self.proxy.StopChecker(dbus_interface = client_interface,
366
ignore_reply=True)
362
self.proxy.Set(client_interface, "CheckerRunning",
363
dbus.Boolean(False), ignore_reply=True,
364
dbus_interface=dbus.PROPERTIES_IFACE)
367
365
elif key == "C":
368
self.proxy.CheckedOK(dbus_interface = client_interface,
366
self.proxy.CheckedOK(dbus_interface=client_interface,
369
367
ignore_reply=True)
370
368
# xxx
371
369
# elif key == "p" or key == "=":
376
374
# self.open()
377
375
else:
378
376
return key
379
380
def property_changed(self, property=None, **kwargs):
381
"""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.
382
380
This overrides the method from MandosClientPropertyCache"""
383
property_name = str(property)
384
old_value = self.properties.get(property_name)
385
super(MandosClientWidget, self).property_changed(
386
property=property, **kwargs)
387
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):
388
387
self.update()
389
388
390
389
394
393
use them as an excuse to shift focus away from this widget.
395
394
"""
396
395
def keypress(self, *args, **kwargs):
397
ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
396
ret = (super(ConstrainedListBox, self)
397
.keypress(*args, **kwargs))
398
398
if ret in ("up", "down"):
399
399
return
400
400
return ret
406
406
"""
407
407
def __init__(self, max_log_length=1000, log_level=1):
408
408
DBusGMainLoop(set_as_default=True)
409
409
410
410
self.screen = urwid.curses_display.Screen()
411
411
412
412
self.screen.register_palette((
413
413
("normal",
414
414
"default", "default", None),
419
419
("standout",
420
420
"standout", "default", "standout"),
421
421
("bold-underline-blink",
422
"bold,underline,blink", "default", "bold,underline,blink"),
422
"bold,underline,blink", "default",
423
"bold,underline,blink"),
423
424
("bold-standout",
424
425
"bold,standout", "default", "bold,standout"),
425
426
("underline-blink-standout",
429
430
"bold,underline,blink,standout", "default",
430
431
"bold,underline,blink,standout"),
431
432
))
432
433
433
434
if urwid.supports_unicode():
434
self.divider = "─" # \u2500
435
#self.divider = "━" # \u2501
435
self.divider = "─" # \u2500
436
436
else:
437
#self.divider = "-" # \u002d
438
self.divider = "_" # \u005f
439
437
self.divider = "_" # \u005f
438
440
439
self.screen.start()
441
440
442
441
self.size = self.screen.get_cols_rows()
443
442
444
443
self.clients = urwid.SimpleListWalker([])
445
444
self.clients_dict = {}
446
445
447
446
# We will add Text widgets to this list
448
self.log = []
447
self.log = urwid.SimpleListWalker([])
449
448
self.max_log_length = max_log_length
450
449
451
450
self.log_level = log_level
452
451
453
452
# We keep a reference to the log widget so we can remove it
454
453
# from the ListWalker without it getting destroyed
455
454
self.logbox = ConstrainedListBox(self.log)
456
455
457
456
# This keeps track of whether self.uilist currently has
458
457
# self.logbox in it or not
459
458
self.log_visible = True
460
459
self.log_wrap = "any"
461
460
462
461
self.rebuild()
463
462
self.log_message_raw(("bold",
464
463
"Mandos Monitor version " + version))
465
464
self.log_message_raw(("bold",
466
465
"q: Quit ?: Help"))
467
466
468
467
self.busname = domain + '.Mandos'
469
self.main_loop = gobject.MainLoop()
470
468
self.main_loop = GLib.MainLoop()
469
471
470
def client_not_found(self, fingerprint, address):
472
self.log_message("Client with address {0} and fingerprint"
473
" {1} could not be found"
471
self.log_message("Client with address {} and fingerprint {}"
472
" could not be found"
474
473
.format(address, fingerprint))
475
474
476
475
def rebuild(self):
477
476
"""This rebuilds the User Interface.
478
477
Call this when the widget layout needs to change"""
479
478
self.uilist = []
480
#self.uilist.append(urwid.ListBox(self.clients))
479
# self.uilist.append(urwid.ListBox(self.clients))
481
480
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
482
481
clients),
483
#header=urwid.Divider(),
482
# header=urwid.Divider(),
484
483
header=None,
485
footer=
486
urwid.Divider(div_char=
487
self.divider)))
484
footer=urwid.Divider(
485
div_char=self.divider)))
488
486
if self.log_visible:
489
487
self.uilist.append(self.logbox)
490
488
self.topwidget = urwid.Pile(self.uilist)
491
489
492
490
def log_message(self, message, level=1):
493
491
"""Log message formatted with timestamp"""
494
492
if level < self.log_level:
495
493
return
496
494
timestamp = datetime.datetime.now().isoformat()
497
self.log_message_raw("{0}: {1}".format(timestamp, message),
495
self.log_message_raw("{}: {}".format(timestamp, message),
498
496
level=level)
499
497
500
498
def log_message_raw(self, markup, level=1):
501
499
"""Add a log message to the log buffer."""
502
500
if level < self.log_level:
503
501
return
504
502
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
505
if (self.max_log_length
506
and len(self.log) > self.max_log_length):
507
del self.log[0:len(self.log)-self.max_log_length-1]
508
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,
509
507
coming_from="above")
510
508
self.refresh()
511
509
512
510
def toggle_log_display(self):
513
511
"""Toggle visibility of the log buffer."""
514
512
self.log_visible = not self.log_visible
515
513
self.rebuild()
516
self.log_message("Log visibility changed to: {0}"
514
self.log_message("Log visibility changed to: {}"
517
515
.format(self.log_visible), level=0)
518
516
519
517
def change_log_display(self):
520
518
"""Change type of log display.
521
519
Currently, this toggles wrapping of text lines."""
525
523
self.log_wrap = "clip"
526
524
for textwidget in self.log:
527
525
textwidget.set_wrap_mode(self.log_wrap)
528
self.log_message("Wrap mode: {0}".format(self.log_wrap),
526
self.log_message("Wrap mode: {}".format(self.log_wrap),
529
527
level=0)
530
531
def find_and_remove_client(self, path, name):
528
529
def find_and_remove_client(self, path, interfaces):
532
530
"""Find a client by its object path and remove it.
533
534
This is connected to the ClientRemoved signal from the
531
532
This is connected to the InterfacesRemoved signal from the
535
533
Mandos server object."""
534
if client_interface not in interfaces:
535
# Not a Mandos client object; ignore
536
return
536
537
try:
537
538
client = self.clients_dict[path]
538
539
except KeyError:
539
540
# not found?
540
self.log_message("Unknown client {0!r} ({1!r}) removed"
541
.format(name, path))
541
self.log_message("Unknown client {!r} removed"
542
.format(path))
542
543
return
543
544
client.delete()
544
545
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
546
555
client_proxy_object = self.bus.get_object(self.busname, path)
547
self.add_client(MandosClientWidget(server_proxy_object
548
=self.mandos_serv,
549
proxy_object
550
=client_proxy_object,
551
update_hook
552
=self.refresh,
553
delete_hook
554
=self.remove_client,
555
logger
556
=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])),
557
563
path=path)
558
564
559
565
def add_client(self, client, path=None):
560
566
self.clients.append(client)
561
567
if path is None:
563
569
self.clients_dict[path] = client
564
570
self.clients.sort(key=lambda c: c.properties["Name"])
565
571
self.refresh()
566
572
567
573
def remove_client(self, client, path=None):
568
574
self.clients.remove(client)
569
575
if path is None:
570
576
path = client.proxy.object_path
571
577
del self.clients_dict[path]
572
578
self.refresh()
573
579
574
580
def refresh(self):
575
581
"""Redraw the screen"""
576
582
canvas = self.topwidget.render(self.size, focus=True)
577
583
self.screen.draw_screen(self.size, canvas)
578
584
579
585
def run(self):
580
586
"""Start the main loop and exit when it's done."""
581
587
self.bus = dbus.SystemBus()
582
588
mandos_dbus_objc = self.bus.get_object(
583
589
self.busname, "/", follow_name_owner_changes=True)
584
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
585
dbus_interface
586
= server_interface)
590
self.mandos_serv = dbus.Interface(
591
mandos_dbus_objc, dbus_interface=server_interface)
587
592
try:
588
593
mandos_clients = (self.mandos_serv
589
594
.GetAllClientsWithProperties())
590
595
if not mandos_clients:
591
self.log_message_raw(("bold", "Note: Server has no clients."))
596
self.log_message_raw(("bold",
597
"Note: Server has no clients."))
592
598
except dbus.exceptions.DBusException:
593
self.log_message_raw(("bold", "Note: No Mandos server running."))
599
self.log_message_raw(("bold",
600
"Note: No Mandos server running."))
594
601
mandos_clients = dbus.Dictionary()
595
602
596
603
(self.mandos_serv
597
.connect_to_signal("ClientRemoved",
604
.connect_to_signal("InterfacesRemoved",
598
605
self.find_and_remove_client,
599
dbus_interface=server_interface,
606
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
600
607
byte_arrays=True))
601
608
(self.mandos_serv
602
.connect_to_signal("ClientAdded",
609
.connect_to_signal("InterfacesAdded",
603
610
self.add_new_client,
604
dbus_interface=server_interface,
611
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
605
612
byte_arrays=True))
606
613
(self.mandos_serv
607
614
.connect_to_signal("ClientNotFound",
611
618
for path, client in mandos_clients.items():
612
619
client_proxy_object = self.bus.get_object(self.busname,
613
620
path)
614
self.add_client(MandosClientWidget(server_proxy_object
615
=self.mandos_serv,
616
proxy_object
617
=client_proxy_object,
618
properties=client,
619
update_hook
620
=self.refresh,
621
delete_hook
622
=self.remove_client,
623
logger
624
=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),
625
628
path=path)
626
629
627
630
self.refresh()
628
self._input_callback_tag = (gobject.io_add_watch
631
self._input_callback_tag = (GLib.io_add_watch
629
632
(sys.stdin.fileno(),
630
gobject.IO_IN,
633
GLib.IO_IN,
631
634
self.process_input))
632
635
self.main_loop.run()
633
636
# Main loop has finished, we should close everything now
634
gobject.source_remove(self._input_callback_tag)
637
GLib.source_remove(self._input_callback_tag)
635
638
self.screen.stop()
636
639
637
640
def stop(self):
638
641
self.main_loop.quit()
639
642
640
643
def process_input(self, source, condition):
641
644
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
}
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
}
652
655
for key in keys:
653
656
try:
654
657
key = translations[key]
655
658
except KeyError: # :-)
656
659
pass
657
660
658
661
if key == "q" or key == "Q":
659
662
self.stop()
660
663
break
661
664
elif key == "window resize":
662
665
self.size = self.screen.get_cols_rows()
663
666
self.refresh()
664
elif key == "\f": # Ctrl-L
667
elif key == "ctrl l":
668
self.screen.clear()
665
669
self.refresh()
666
670
elif key == "l" or key == "D":
667
671
self.toggle_log_display()
707
711
else:
708
712
self.log_level = 0
709
713
self.log_message("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
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
728
732
elif self.topwidget.selectable():
729
733
self.topwidget.keypress(self.size, key)
730
734
self.refresh()
731
735
return True
732
736
737
733
738
ui = UserInterface()
734
739
try:
735
740
ui.run()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0