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 544
- compare with another revision
- download diff
- download tarball
- view history from revision 544
- Committer: Teddy Hogeborn
- Date: 2011-12-31 23:05:34 UTC
- Revision ID: teddy@recompile.se-20111231230534-o5w0uhwx30gwhmk7
Updated year in copyright notices.
- files removed:
- bugs.xml
- debian/upstream
- plugin-helpers
- files modified:
- .bzrignore
added
removed
mandos-monitor
3
3
#
4
4
# Mandos Monitor - Control and monitor the Mandos server
5
5
#
6
# Copyright © 2009-2016 Teddy Hogeborn
7
# Copyright © 2009-2016 Björn Påhlsson
6
# Copyright © 2009-2012 Teddy Hogeborn
7
# Copyright © 2009-2012 Björn Påhlsson
8
8
#
9
9
# This program is free software: you can redistribute it and/or modify
10
10
# it under the terms of the GNU General Public License as published by
17
17
# GNU General Public License for more details.
18
18
#
19
19
# 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/>.
20
# along with this program. If not, see <http://www.gnu.org/licenses/>.
22
21
#
23
22
# Contact the authors at <mandos@recompile.se>.
24
23
#
25
24
26
25
from __future__ import (division, absolute_import, print_function,
27
26
unicode_literals)
28
try:
29
from future_builtins import *
30
except ImportError:
31
pass
32
27
33
28
import sys
34
29
import os
30
import signal
35
31
36
32
import datetime
37
33
39
35
import urwid
40
36
41
37
from dbus.mainloop.glib import DBusGMainLoop
42
from gi.repository import GLib
38
import gobject
43
39
44
40
import dbus
45
41
42
import UserList
43
46
44
import locale
47
45
48
if sys.version_info.major == 2:
49
str = unicode
50
51
46
locale.setlocale(locale.LC_ALL, '')
52
47
53
48
import logging
57
52
domain = 'se.recompile'
58
53
server_interface = domain + '.Mandos'
59
54
client_interface = domain + '.Mandos.Client'
60
version = "1.7.9"
61
62
try:
63
dbus.OBJECT_MANAGER_IFACE
64
except AttributeError:
65
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
55
version = "1.4.1"
56
57
# Always run in monochrome mode
58
urwid.curses_display.curses.has_colors = lambda : False
59
60
# Urwid doesn't support blinking, but we want it. Since we have no
61
# use for underline on its own, we make underline also always blink.
62
urwid.curses_display.curses.A_UNDERLINE |= (
63
urwid.curses_display.curses.A_BLINK)
66
64
67
65
def isoformat_to_datetime(iso):
68
66
"Parse an ISO 8601 date string to a datetime.datetime()"
85
83
properties and calls a hook function when any of them are
86
84
changed.
87
85
"""
88
def __init__(self, proxy_object=None, properties=None, **kwargs):
86
def __init__(self, proxy_object=None, *args, **kwargs):
89
87
self.proxy = proxy_object # Mandos Client proxy object
90
self.properties = dict() if properties is None else properties
88
89
self.properties = dict()
91
90
self.property_changed_match = (
92
self.proxy.connect_to_signal("PropertiesChanged",
93
self.properties_changed,
94
dbus.PROPERTIES_IFACE,
91
self.proxy.connect_to_signal("PropertyChanged",
92
self.property_changed,
93
client_interface,
95
94
byte_arrays=True))
96
95
97
if properties is None:
98
self.properties.update(
99
self.proxy.GetAll(client_interface,
100
dbus_interface
101
= dbus.PROPERTIES_IFACE))
102
103
super(MandosClientPropertyCache, self).__init__(**kwargs)
96
self.properties.update(
97
self.proxy.GetAll(client_interface,
98
dbus_interface = dbus.PROPERTIES_IFACE))
99
100
#XXX This breaks good super behaviour
101
# super(MandosClientPropertyCache, self).__init__(
102
# *args, **kwargs)
104
103
105
def properties_changed(self, interface, properties, invalidated):
106
"""This is called whenever we get a PropertiesChanged signal
107
It updates the changed properties in the "properties" dict.
104
def property_changed(self, property=None, value=None):
105
"""This is called whenever we get a PropertyChanged signal
106
It updates the changed property in the "properties" dict.
108
107
"""
109
108
# Update properties dict with new value
110
if interface == client_interface:
111
self.properties.update(properties)
109
self.properties[property] = value
112
110
113
def delete(self):
111
def delete(self, *args, **kwargs):
114
112
self.property_changed_match.remove()
113
super(MandosClientPropertyCache, self).__init__(
114
*args, **kwargs)
115
115
116
116
117
117
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
119
119
"""
120
120
121
121
def __init__(self, server_proxy_object=None, update_hook=None,
122
delete_hook=None, logger=None, **kwargs):
122
delete_hook=None, logger=None, *args, **kwargs):
123
123
# Called on update
124
124
self.update_hook = update_hook
125
125
# Called on delete
130
130
self.logger = logger
131
131
132
132
self._update_timer_callback_tag = None
133
self._update_timer_callback_lock = 0
134
self.last_checker_failed = False
133
135
134
136
# The widget shown normally
135
137
self._text_widget = urwid.Text("")
136
138
# The widget shown when we have focus
137
139
self._focus_text_widget = urwid.Text("")
138
super(MandosClientWidget, self).__init__(**kwargs)
140
super(MandosClientWidget, self).__init__(
141
update_hook=update_hook, delete_hook=delete_hook,
142
*args, **kwargs)
139
143
self.update()
140
144
self.opened = False
141
145
146
last_checked_ok = isoformat_to_datetime(self.properties
147
["LastCheckedOK"])
148
if last_checked_ok is None:
149
self.last_checker_failed = True
150
else:
151
self.last_checker_failed = ((datetime.datetime.utcnow()
152
- last_checked_ok)
153
> datetime.timedelta
154
(milliseconds=
155
self.properties
156
["Interval"]))
157
158
if self.last_checker_failed:
159
self.using_timer(True)
160
161
if self.need_approval:
162
self.using_timer(True)
163
142
164
self.match_objects = (
143
165
self.proxy.connect_to_signal("CheckerCompleted",
144
166
self.checker_completed,
160
182
self.rejected,
161
183
client_interface,
162
184
byte_arrays=True))
163
self.logger('Created client {}'
164
.format(self.properties["Name"]), level=0)
185
#self.logger('Created client %s' % (self.properties["Name"]))
165
186
187
def property_changed(self, property=None, value=None):
188
super(self, MandosClientWidget).property_changed(property,
189
value)
190
if property == "ApprovalPending":
191
using_timer(bool(value))
192
166
193
def using_timer(self, flag):
167
194
"""Call this method with True or False when timer should be
168
195
activated or deactivated.
169
196
"""
170
if flag and self._update_timer_callback_tag is None:
197
old = self._update_timer_callback_lock
198
if flag:
199
self._update_timer_callback_lock += 1
200
else:
201
self._update_timer_callback_lock -= 1
202
if old == 0 and self._update_timer_callback_lock:
171
203
# Will update the shown timer value every second
172
self._update_timer_callback_tag = (GLib.timeout_add
204
self._update_timer_callback_tag = (gobject.timeout_add
173
205
(1000,
174
206
self.update_timer))
175
elif not (flag or self._update_timer_callback_tag is None):
176
GLib.source_remove(self._update_timer_callback_tag)
207
elif old and self._update_timer_callback_lock == 0:
208
gobject.source_remove(self._update_timer_callback_tag)
177
209
self._update_timer_callback_tag = None
178
210
179
211
def checker_completed(self, exitstatus, condition, command):
180
212
if exitstatus == 0:
181
self.logger('Checker for client {} (command "{}")'
182
' succeeded'.format(self.properties["Name"],
183
command), level=0)
213
if self.last_checker_failed:
214
self.last_checker_failed = False
215
self.using_timer(False)
216
#self.logger('Checker for client %s (command "%s")'
217
# ' was successful'
218
# % (self.properties["Name"], command))
184
219
self.update()
185
220
return
186
221
# Checker failed
222
if not self.last_checker_failed:
223
self.last_checker_failed = True
224
self.using_timer(True)
187
225
if os.WIFEXITED(condition):
188
self.logger('Checker for client {} (command "{}") failed'
189
' with exit code {}'
190
.format(self.properties["Name"], command,
191
os.WEXITSTATUS(condition)))
226
self.logger('Checker for client %s (command "%s")'
227
' failed with exit code %s'
228
% (self.properties["Name"], command,
229
os.WEXITSTATUS(condition)))
192
230
elif os.WIFSIGNALED(condition):
193
self.logger('Checker for client {} (command "{}") was'
194
' killed by signal {}'
195
.format(self.properties["Name"], command,
196
os.WTERMSIG(condition)))
231
self.logger('Checker for client %s (command "%s")'
232
' was killed by signal %s'
233
% (self.properties["Name"], command,
234
os.WTERMSIG(condition)))
235
elif os.WCOREDUMP(condition):
236
self.logger('Checker for client %s (command "%s")'
237
' dumped core'
238
% (self.properties["Name"], command))
239
else:
240
self.logger('Checker for client %s completed'
241
' mysteriously')
197
242
self.update()
198
243
199
244
def checker_started(self, command):
200
"""Server signals that a checker started."""
201
self.logger('Client {} started checker "{}"'
202
.format(self.properties["Name"],
203
command), level=0)
245
"""Server signals that a checker started. This could be useful
246
to log in the future. """
247
#self.logger('Client %s started checker "%s"'
248
# % (self.properties["Name"], unicode(command)))
249
pass
204
250
205
251
def got_secret(self):
206
self.logger('Client {} received its secret'
207
.format(self.properties["Name"]))
252
self.last_checker_failed = False
253
self.logger('Client %s received its secret'
254
% self.properties["Name"])
208
255
209
256
def need_approval(self, timeout, default):
210
257
if not default:
211
message = 'Client {} needs approval within {} seconds'
258
message = 'Client %s needs approval within %s seconds'
212
259
else:
213
message = 'Client {} will get its secret in {} seconds'
214
self.logger(message.format(self.properties["Name"],
215
timeout/1000))
260
message = 'Client %s will get its secret in %s seconds'
261
self.logger(message
262
% (self.properties["Name"], timeout/1000))
263
self.using_timer(True)
216
264
217
265
def rejected(self, reason):
218
self.logger('Client {} was rejected; reason: {}'
219
.format(self.properties["Name"], reason))
266
self.logger('Client %s was rejected; reason: %s'
267
% (self.properties["Name"], reason))
220
268
221
269
def selectable(self):
222
270
"""Make this a "selectable" widget.
244
292
"bold-underline-blink":
245
293
"bold-underline-blink-standout",
246
294
}
247
295
248
296
# Rebuild focus and non-focus widgets using current properties
249
297
250
298
# Base part of a client. Name!
251
base = '{name}: '.format(name=self.properties["Name"])
299
base = ('%(name)s: '
300
% {"name": self.properties["Name"]})
252
301
if not self.properties["Enabled"]:
253
302
message = "DISABLED"
254
self.using_timer(False)
255
303
elif self.properties["ApprovalPending"]:
256
304
timeout = datetime.timedelta(milliseconds
257
305
= self.properties
259
307
last_approval_request = isoformat_to_datetime(
260
308
self.properties["LastApprovalRequest"])
261
309
if last_approval_request is not None:
262
timer = max(timeout - (datetime.datetime.utcnow()
263
- last_approval_request),
264
datetime.timedelta())
310
timer = timeout - (datetime.datetime.utcnow()
311
- last_approval_request)
265
312
else:
266
313
timer = datetime.timedelta()
267
314
if self.properties["ApprovedByDefault"]:
268
message = "Approval in {}. (d)eny?"
315
message = "Approval in %s. (d)eny?"
269
316
else:
270
message = "Denial in {}. (a)pprove?"
271
message = message.format(str(timer).rsplit(".", 1)[0])
272
self.using_timer(True)
273
elif self.properties["LastCheckerStatus"] != 0:
274
# When checker has failed, show timer until client expires
317
message = "Denial in %s. (a)pprove?"
318
message = message % unicode(timer).rsplit(".", 1)[0]
319
elif self.last_checker_failed:
320
# When checker has failed, print a timer until client expires
275
321
expires = self.properties["Expires"]
276
322
if expires == "":
277
323
timer = datetime.timedelta(0)
278
324
else:
279
expires = (datetime.datetime.strptime
280
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
281
timer = max(expires - datetime.datetime.utcnow(),
282
datetime.timedelta())
325
expires = datetime.datetime.strptime(expires,
326
'%Y-%m-%dT%H:%M:%S.%f')
327
timer = expires - datetime.datetime.utcnow()
283
328
message = ('A checker has failed! Time until client'
284
' gets disabled: {}'
285
.format(str(timer).rsplit(".", 1)[0]))
286
self.using_timer(True)
329
' gets disabled: %s'
330
% unicode(timer).rsplit(".", 1)[0])
287
331
else:
288
332
message = "enabled"
289
self.using_timer(False)
290
self._text = "{}{}".format(base, message)
291
333
self._text = "%s%s" % (base, message)
334
292
335
if not urwid.supports_unicode():
293
336
self._text = self._text.encode("ascii", "replace")
294
337
textlist = [("normal", self._text)]
306
349
self.update_hook()
307
350
308
351
def update_timer(self):
309
"""called by GLib. Will indefinitely loop until
310
GLib.source_remove() on tag is called
311
"""
352
"""called by gobject. Will indefinitely loop until
353
gobject.source_remove() on tag is called"""
312
354
self.update()
313
355
return True # Keep calling this
314
356
315
def delete(self, **kwargs):
357
def delete(self, *args, **kwargs):
316
358
if self._update_timer_callback_tag is not None:
317
GLib.source_remove(self._update_timer_callback_tag)
359
gobject.source_remove(self._update_timer_callback_tag)
318
360
self._update_timer_callback_tag = None
319
361
for match in self.match_objects:
320
362
match.remove()
321
363
self.match_objects = ()
322
364
if self.delete_hook is not None:
323
365
self.delete_hook(self)
324
return super(MandosClientWidget, self).delete(**kwargs)
366
return super(MandosClientWidget, self).delete(*args, **kwargs)
325
367
326
368
def render(self, maxcolrow, focus=False):
327
369
"""Render differently if we have focus.
333
375
"""Handle keys.
334
376
This overrides the method from urwid.FlowWidget"""
335
377
if key == "+":
336
self.proxy.Set(client_interface, "Enabled",
337
dbus.Boolean(True), ignore_reply = True,
338
dbus_interface = dbus.PROPERTIES_IFACE)
378
self.proxy.Enable(dbus_interface = client_interface,
379
ignore_reply=True)
339
380
elif key == "-":
340
self.proxy.Set(client_interface, "Enabled", False,
341
ignore_reply = True,
342
dbus_interface = dbus.PROPERTIES_IFACE)
381
self.proxy.Disable(dbus_interface = client_interface,
382
ignore_reply=True)
343
383
elif key == "a":
344
384
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
345
385
dbus_interface = client_interface,
353
393
.object_path,
354
394
ignore_reply=True)
355
395
elif key == "s":
356
self.proxy.Set(client_interface, "CheckerRunning",
357
dbus.Boolean(True), ignore_reply = True,
358
dbus_interface = dbus.PROPERTIES_IFACE)
396
self.proxy.StartChecker(dbus_interface = client_interface,
397
ignore_reply=True)
359
398
elif key == "S":
360
self.proxy.Set(client_interface, "CheckerRunning",
361
dbus.Boolean(False), ignore_reply = True,
362
dbus_interface = dbus.PROPERTIES_IFACE)
399
self.proxy.StopChecker(dbus_interface = client_interface,
400
ignore_reply=True)
363
401
elif key == "C":
364
402
self.proxy.CheckedOK(dbus_interface = client_interface,
365
403
ignore_reply=True)
373
411
else:
374
412
return key
375
413
376
def properties_changed(self, interface, properties, invalidated):
377
"""Call self.update() if any properties changed.
414
def property_changed(self, property=None, value=None,
415
*args, **kwargs):
416
"""Call self.update() if old value is not new value.
378
417
This overrides the method from MandosClientPropertyCache"""
379
old_values = { key: self.properties.get(key)
380
for key in properties.keys() }
381
super(MandosClientWidget, self).properties_changed(
382
interface, properties, invalidated)
383
if any(old_values[key] != self.properties.get(key)
384
for key in old_values):
418
property_name = unicode(property)
419
old_value = self.properties.get(property_name)
420
super(MandosClientWidget, self).property_changed(
421
property=property, value=value, *args, **kwargs)
422
if self.properties.get(property_name) != old_value:
385
423
self.update()
386
424
387
425
390
428
"down" key presses, thus not allowing any containing widgets to
391
429
use them as an excuse to shift focus away from this widget.
392
430
"""
393
def keypress(self, *args, **kwargs):
394
ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
431
def keypress(self, maxcolrow, key):
432
ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)
395
433
if ret in ("up", "down"):
396
434
return
397
435
return ret
401
439
"""This is the entire user interface - the whole screen
402
440
with boxes, lists of client widgets, etc.
403
441
"""
404
def __init__(self, max_log_length=1000, log_level=1):
442
def __init__(self, max_log_length=1000):
405
443
DBusGMainLoop(set_as_default=True)
406
444
407
445
self.screen = urwid.curses_display.Screen()
410
448
("normal",
411
449
"default", "default", None),
412
450
("bold",
413
"bold", "default", "bold"),
451
"default", "default", "bold"),
414
452
("underline-blink",
415
"underline,blink", "default", "underline,blink"),
453
"default", "default", "underline"),
416
454
("standout",
417
"standout", "default", "standout"),
455
"default", "default", "standout"),
418
456
("bold-underline-blink",
419
"bold,underline,blink", "default", "bold,underline,blink"),
457
"default", "default", ("bold", "underline")),
420
458
("bold-standout",
421
"bold,standout", "default", "bold,standout"),
459
"default", "default", ("bold", "standout")),
422
460
("underline-blink-standout",
423
"underline,blink,standout", "default",
424
"underline,blink,standout"),
461
"default", "default", ("underline", "standout")),
425
462
("bold-underline-blink-standout",
426
"bold,underline,blink,standout", "default",
427
"bold,underline,blink,standout"),
463
"default", "default", ("bold", "underline",
464
"standout")),
428
465
))
429
466
430
467
if urwid.supports_unicode():
445
482
self.log = []
446
483
self.max_log_length = max_log_length
447
484
448
self.log_level = log_level
449
450
485
# We keep a reference to the log widget so we can remove it
451
486
# from the ListWalker without it getting destroyed
452
487
self.logbox = ConstrainedListBox(self.log)
463
498
"q: Quit ?: Help"))
464
499
465
500
self.busname = domain + '.Mandos'
466
self.main_loop = GLib.MainLoop()
501
self.main_loop = gobject.MainLoop()
467
502
468
503
def client_not_found(self, fingerprint, address):
469
self.log_message("Client with address {} and fingerprint {}"
470
" could not be found"
471
.format(address, fingerprint))
504
self.log_message(("Client with address %s and fingerprint %s"
505
" could not be found" % (address,
506
fingerprint)))
472
507
473
508
def rebuild(self):
474
509
"""This rebuilds the User Interface.
486
521
self.uilist.append(self.logbox)
487
522
self.topwidget = urwid.Pile(self.uilist)
488
523
489
def log_message(self, message, level=1):
490
"""Log message formatted with timestamp"""
491
if level < self.log_level:
492
return
524
def log_message(self, message):
493
525
timestamp = datetime.datetime.now().isoformat()
494
self.log_message_raw("{}: {}".format(timestamp, message),
495
level=level)
526
self.log_message_raw(timestamp + ": " + message)
496
527
497
def log_message_raw(self, markup, level=1):
528
def log_message_raw(self, markup):
498
529
"""Add a log message to the log buffer."""
499
if level < self.log_level:
500
return
501
530
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
502
531
if (self.max_log_length
503
532
and len(self.log) > self.max_log_length):
510
539
"""Toggle visibility of the log buffer."""
511
540
self.log_visible = not self.log_visible
512
541
self.rebuild()
513
self.log_message("Log visibility changed to: {}"
514
.format(self.log_visible), level=0)
542
#self.log_message("Log visibility changed to: "
543
# + unicode(self.log_visible))
515
544
516
545
def change_log_display(self):
517
546
"""Change type of log display.
522
551
self.log_wrap = "clip"
523
552
for textwidget in self.log:
524
553
textwidget.set_wrap_mode(self.log_wrap)
525
self.log_message("Wrap mode: {}".format(self.log_wrap),
526
level=0)
554
#self.log_message("Wrap mode: " + self.log_wrap)
527
555
528
def find_and_remove_client(self, path, interfaces):
556
def find_and_remove_client(self, path, name):
529
557
"""Find a client by its object path and remove it.
530
558
531
This is connected to the InterfacesRemoved signal from the
559
This is connected to the ClientRemoved signal from the
532
560
Mandos server object."""
533
if client_interface not in interfaces:
534
# Not a Mandos client object; ignore
535
return
536
561
try:
537
562
client = self.clients_dict[path]
538
563
except KeyError:
539
564
# not found?
540
self.log_message("Unknown client {!r} removed"
541
.format(path))
565
self.log_message("Unknown client %r (%r) removed", name,
566
path)
542
567
return
543
568
client.delete()
544
569
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
570
def add_new_client(self, path):
554
571
client_proxy_object = self.bus.get_object(self.busname, path)
555
572
self.add_client(MandosClientWidget(server_proxy_object
556
573
=self.mandos_serv,
561
578
delete_hook
562
579
=self.remove_client,
563
580
logger
564
=self.log_message,
565
properties
566
= dict(ifs_and_props[
567
client_interface])),
581
=self.log_message),
568
582
path=path)
569
583
570
584
def add_client(self, client, path=None):
572
586
if path is None:
573
587
path = client.proxy.object_path
574
588
self.clients_dict[path] = client
575
self.clients.sort(key=lambda c: c.properties["Name"])
589
self.clients.sort(None, lambda c: c.properties["Name"])
576
590
self.refresh()
577
591
578
592
def remove_client(self, client, path=None):
580
594
if path is None:
581
595
path = client.proxy.object_path
582
596
del self.clients_dict[path]
597
if not self.clients_dict:
598
# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
599
# is completely emptied, we need to recreate it.
600
self.clients = urwid.SimpleListWalker([])
601
self.rebuild()
583
602
self.refresh()
584
603
585
604
def refresh(self):
598
617
try:
599
618
mandos_clients = (self.mandos_serv
600
619
.GetAllClientsWithProperties())
601
if not mandos_clients:
602
self.log_message_raw(("bold", "Note: Server has no clients."))
603
620
except dbus.exceptions.DBusException:
604
self.log_message_raw(("bold", "Note: No Mandos server running."))
605
621
mandos_clients = dbus.Dictionary()
606
622
607
623
(self.mandos_serv
608
.connect_to_signal("InterfacesRemoved",
624
.connect_to_signal("ClientRemoved",
609
625
self.find_and_remove_client,
610
dbus_interface
611
= dbus.OBJECT_MANAGER_IFACE,
626
dbus_interface=server_interface,
612
627
byte_arrays=True))
613
628
(self.mandos_serv
614
.connect_to_signal("InterfacesAdded",
629
.connect_to_signal("ClientAdded",
615
630
self.add_new_client,
616
dbus_interface
617
= dbus.OBJECT_MANAGER_IFACE,
631
dbus_interface=server_interface,
618
632
byte_arrays=True))
619
633
(self.mandos_serv
620
634
.connect_to_signal("ClientNotFound",
621
635
self.client_not_found,
622
636
dbus_interface=server_interface,
623
637
byte_arrays=True))
624
for path, client in mandos_clients.items():
638
for path, client in mandos_clients.iteritems():
625
639
client_proxy_object = self.bus.get_object(self.busname,
626
640
path)
627
641
self.add_client(MandosClientWidget(server_proxy_object
636
650
logger
637
651
=self.log_message),
638
652
path=path)
639
653
640
654
self.refresh()
641
self._input_callback_tag = (GLib.io_add_watch
655
self._input_callback_tag = (gobject.io_add_watch
642
656
(sys.stdin.fileno(),
643
GLib.IO_IN,
657
gobject.IO_IN,
644
658
self.process_input))
645
659
self.main_loop.run()
646
660
# Main loop has finished, we should close everything now
647
GLib.source_remove(self._input_callback_tag)
661
gobject.source_remove(self._input_callback_tag)
648
662
self.screen.stop()
649
663
650
664
def stop(self):
674
688
elif key == "window resize":
675
689
self.size = self.screen.get_cols_rows()
676
690
self.refresh()
677
elif key == "ctrl l":
678
self.screen.clear()
691
elif key == "\f": # Ctrl-L
679
692
self.refresh()
680
693
elif key == "l" or key == "D":
681
694
self.toggle_log_display()
693
706
"?: Help",
694
707
"l: Log window toggle",
695
708
"TAB: Switch window",
696
"w: Wrap (log lines)",
697
"v: Toggle verbose log",
698
))))
709
"w: Wrap (log)"))))
699
710
self.log_message_raw(("bold",
700
711
" "
701
712
.join(("Clients:",
714
725
else:
715
726
self.topwidget.set_focus(self.logbox)
716
727
self.refresh()
717
elif key == "v":
718
if self.log_level == 0:
719
self.log_level = 1
720
self.log_message("Verbose mode: Off")
721
else:
722
self.log_level = 0
723
self.log_message("Verbose mode: On")
724
728
#elif (key == "end" or key == "meta >" or key == "G"
725
729
# or key == ">"):
726
730
# pass # xxx end-of-buffer
749
753
ui.run()
750
754
except KeyboardInterrupt:
751
755
ui.screen.stop()
752
except Exception as e:
753
ui.log_message(str(e))
756
except Exception, e:
757
ui.log_message(unicode(e))
754
758
ui.screen.stop()
755
759
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0